'Un modelo de cómputo basado en ocultamiento de la ...

Di r ecci ó n:Di r ecci ó n: Biblioteca Central Dr. Luis F. Leloir, Facultad de Ciencias Exactas y Naturales, Universidad de Buenos Aires. Intendente Güiraldes 2160 - C1428EGA - Tel. (++54 +11) 4789-9293

Co nta cto :Co nta cto : [email protected]

Tesis Doctoral

Un modelo de cómputo basado enUn modelo de cómputo basado enocultamiento de la información paraocultamiento de la información para

cotas inferiores de complejidad encotas inferiores de complejidad engeometría algebraica efectivageometría algebraica efectiva

Rojas Paredes, Andrés Avelino

2018-02-26

Este documento forma parte de la colección de tesis doctorales y de maestría de la BibliotecaCentral Dr. Luis Federico Leloir, disponible en digital.bl.fcen.uba.ar. Su utilización debe seracompañada por la cita bibliográfica con reconocimiento de la fuente.

This document is part of the doctoral theses collection of the Central Library Dr. Luis FedericoLeloir, available in digital.bl.fcen.uba.ar. It should be used accompanied by the correspondingcitation acknowledging the source.

Cita tipo APA:

Rojas Paredes, Andrés Avelino. (2018-02-26). Un modelo de cómputo basado en ocultamiento dela información para cotas inferiores de complejidad en geometría algebraica efectiva. Facultadde Ciencias Exactas y Naturales. Universidad de Buenos Aires.

Cita tipo Chicago:

Rojas Paredes, Andrés Avelino. "Un modelo de cómputo basado en ocultamiento de lainformación para cotas inferiores de complejidad en geometría algebraica efectiva". Facultadde Ciencias Exactas y Naturales. Universidad de Buenos Aires. 2018-02-26.

http://digital.bl.fcen.uba.ar

http://digital.bl.fcen.uba.ar

mailto:[email protected]

Universidad de Buenos AiresFacultad de Ciencias Exactas y Naturales

Departamento de Computación

Un modelo de cómputo basado en ocultamiento de la información

para cotas inferiores de complejidad en

geometría algebraica efectiva

Tesis presentada para optar al títulode Doctor de la Universidad de Buenos Airesen el área de Ciencias de la Computación

Andrés Avelino Rojas Paredes

Director de tesis: Joos HeintzConsejero de estudios: Diego GarbervetskyLugar de trabajo: Departamento de Computación, Facultad de Ciencias

Exactas y Naturales, Universidad de Buenos Aires

Fecha de defensa: 26 de Febrero de 2018

Agradecimientos

Agradezco en primer lugar a mi director Joos Heintz. Es para mi unprivilegio aprender y trabajar a su lado. Trabajar con el profesor Jooses como realizar un viaje de aventura y chocarse en el camino con losproblemas más difíciles de la ciencia. Este viaje incluye pensar respuestasa problemas y hacer reuniones debajo de un árbol en la facultad, tomandonotas bajo el sol ó bajo la lluvia.

Agradezco también al jurado evaluador integrado por: Santiago Figueira(Departamento de Computación, FCEyN, Universidad de Buenos Aires),Teresa Krick (Departamento de Matemática, FCEyN, Universidad de BuenosAires) y Claudia Pons (Laboratorio de Investigación y Formación en Infor-mática Avanzada, Facultad de Informática, Universidad Nacional de LaPlata), por los comentarios y correcciones que ayudaron a mejorar estetrabajo.

Agradezco al programa de becas de ayuda económica Sadosky que meayudó a terminar la carrera de grado. Sin esta beca quizá hubiera aban-donado por problemas económicos y nunca hubiera llegado a conocer laposibilidad de hacer un doctorado. En este sentido, gracias también aSantiago Figueira quien, mientras yo hacia la carrera para analista, medió inspiración con su curso de computabilidad para seguir estudiando yaprender los misterios de las ciencias de la computación.

Finalmente gracias a diferentes personas que intervinieron durante eldesarrollo de esta tesis: Hvara Ocar (pág. 19), Ignacio Stolkin (pág. 47),Alejandro Prieto (pág. 69). Gracias al grupo Lafhis, en especial a SebastiánUchitel y Diego Garbervetsky por críticas y comentarios que ayudaron amejorar esta tesis. Agradezco también a mi teacher Silvia Amalia Leporatipor ayudarme a corregir y mejorar el inglés de más de una sección de estetrabajo. Gracias a la profesora Susana Gallardo y su curso sobre Comuni-cación Cientíca Especializada que me ayudó a redactar la introducción.

Gracias a mi grupo de amigos los Tecnopioneros, a mis compañeros detrabajo de la UTI y en especial a Alejandro Horno Scherz. Gracias a AlexisMartin por tanto conocimiento de informática que también es inspiraciónpara mejorar. Gracias a mi Alejandra y a mi familia, por bancarme siempre.

A. A. Rojas Paredes 3

Dedicado a mi mama Felicidad,a mi adorada Alejandra,

y a mis queridos hermanos Amir y Karina.


Un Modelo de Cómputo basado en Ocultamiento de la

Información para Cotas Inferiores de Complejidad en

Geometría Algebraica Efectiva

Resumen

Para estudiar la complejidad intrínseca de un problema computacionalsiempre es posible dar y demostrar cotas inferiores de complejidad. Unacota inferior de complejidad es un teorema que establece la mínima com-plejidad que tiene cualquier algoritmo que intente resolver el problema queestamos considerando. Con esta denición, una cota posible es Ω(1) que esuna cota inferior trivial, cualquier algoritmo tarda al menos un paso. Lodifícil es obtener una cota inferior alta. Cuanto más alta es la cota infe-rior, es más difícil de demostrar, por ejemplo, aún es una pregunta abiertasaber si existen o no cotas inferiores exponenciales para problemas en laclase de complejidad NP. En esta tesis se establece que la dicultad deencontrar tales cotas puede deberse a la naturaleza del modelo de cóm-puto utilizado que no debe ser general ni muy especíco. Esta idea empezócon la noción de algoritmo programable (programmable algorithm) que dis-tingue entre algoritmos en general y algoritmos producidos siguiendo unaespecicación (ver [HKRP13b]). De acuerdo con [Bor75], obtener una cotainferior de complejidad requiere la denición de dos ingredientes funda-mentales: el modelo de cómputo que contiene los algoritmos que vamos aestudiar y una adecuada medida de complejidad computacional. Entonces,vamos a ser cuidadosos con la denición de estos ingredientes y vamos adenir un modelo de cómputo para algoritmos programables en el sentidode [HKRP13b]. En particular, en esta tesis introducimos un modelo decómputo basado en conceptos de Ingeniería de Software. Esta caracterís-tica permite demostrar cotas inferiores de complejidad no triviales paraalgoritmos de eliminación en geometría algebraica efectiva.

Esta tesis esta basada en un proyecto de 20 años de investigación encomplejidad algebraica y teoría del cálculo simbólico que fue iniciado en eltrabajo J. Heintz, J. Morgenstern, On the Intrinsic Complexity of Elimina-tion Theory, Journal of Complexity 9 471-498 (1993). El objetivo originaldel proyecto fue determinar la complejidad intrínseca de resolver sistemasde ecuaciones polinomiales (teoría de la eliminación), se quería demostrar su


carácter de complejidad nopolinomial. Este objetivo fue logrado en esenciaen el trabajo J. Heintz, B. Kuijpers, A. Rojas Paredes, Software Engineer-ing and Complexity in Eective Algebraic Geometry, Journal of Complexity29 92-138 (2013), Journal of Complexity 2013 Best Paper Award, dondese jó la estructura de datos que utilizaban los algoritmos de eliminación,esto se llamó modelo de circuitos (polinomios implementados en términosde circuitos aritméticos).

Más tarde nos dimos cuenta de que el modelo de circuitos no era esencialy que nuestra argumentación también podía aplicarse a otras cuestiones decomplejidad en el cálculo cientíco, por ejemplo, la interpolación polinomial(ver [GHMS11]). La observación principal fue que habíamos desarrolladoen nuestro contexto un modelo matemático para ciertos aspectos de laIngeniería de Software, en particular, habíamos desarrollado un modelopara el ocultamiento de la información y el requerimiento nofuncional dela robustez, esto nos permitió sacar conclusiones sorprendentes sobre lacomplejidad de los algoritmos de eliminación, ver B. Bank, J. Heintz, G.Matera, J. L. Montaña, L. M. Pardo, A. Rojas Paredes, Quiz Games as aModel for Information Hiding, Journal of Complexity 34 1-29 (2016).

Esta tesis describe un modelo de cómputo que se inspira en las nocionesde ocultamiento de la información y requerimientos nofuncionales, entreotros conceptos importantes en Ingeniería de Software como las nociones deabstracción y el diseño de software. Nuestro modelo de cómputo permiteprobar cotas inferiores de complejidad exponencial para los algoritmos deeliminación. Mostramos que cualquier implementación orientada a objetos(y robusta) de algoritmos de eliminación es necesariamente ineciente. Esteresultado muestra una sinergia existente entre Ingeniería del Software yTeoría de la Complejidad Algebraica.

Palabras claves: Tipo abstracto de datos, función de abstracción, al-goritmo de eliminación, interpolación, ocultamiento de la información, cotainferior de complejidad, requerimiento nofuncional, robustez, diagrama declases, modelo de cómputo, programación orientada a objetos, polinomios,diseño de software


A Computation Model based on Information Hiding

for Lower Complexity Bounds in Eective Algebraic Geometry

Abstract

In order to study the intrinsic complexity of a given computational prob-lem it is always possible to give and prove a complexity lower bound. Acomplexity lower bound is a theorem that establishes the least complexityfor any algorithm which tries to solve the problem we are considering. Thisdenition allow us to say that a lower bound may be Ω(1) which is a triviallower bound, any algorithm takes at least one step. The hardest part ofobtaining a lower bound is to obtain a high lower bound. The higher thelower bound is, the more dicult it is to prove, e.g., it is still an openquestion to know whether or not there exist exponential lower bounds forproblems in the complexity class NP. In this thesis we suggest that thediculty of nding such lower bounds may be due to the characteristicsof the computation model which should not be general nor very specic.This idea started with the notion of programmable algorithm which distin-guishes between algorithms in general and algorithms produced followinga specication (see [HKRP13b]). According to [Bor75], a complexity lowerbound requires the denition of both ingredients: a computation modelwhich contains the algorithms we are going to study and a suitable com-plexity measure. Thus, we are going to carefully dene these ingredients, inparticular, we are going to dene a computation model for programmablealgorithms in the sense of [HKRP13b]. In this thesis we introduce a compu-tation model which is based on concepts from Software Engineering. Thischaracteristic allow us to prove nontrivial complexity lower bounds forelimination algorithms in eective algebraic geometry.

This thesis is based on a 20 years old research project in algebraic com-plexity and symbolic computation theory initiated in J. Heintz, J. Morgen-stern, On the Intrinsic Complexity of Elimination Theory, J. of Complexity9 471-498 (1993). The original aim was to determine the intrinsic com-plexity of polynomial equation solving (elimination theory) and to show itsnonpolynomial complexity character. This goal was essentially achieved inJ. Heintz, B. Kuijpers, A. Rojas Paredes, Software Engineering and Com-plexity in Eective Algebraic Geometry, J. of Complexity 29 92-138 (2013),Journal of Complexity 2013 Best Paper Award. In that work, the main datastructure used for elimination algorithms was xed and studied in a circuitmodel (polynomials implemented in terms of arithmetic circuits).


Later we became aware that the circuit model was unessential and thatour argumentation could also be applied to other complexity questions inscientic computing, e.g., polynomial interpolation. The main observationwas that we had developed in our context a mathematical model for certainaspects of software engineering, in particular for Information Hiding andthe nonfunctional requirement of robustness which allowed us to drawsurprising conclusions for complexity issues, see B. Bank, J. Heintz, G.Matera, J. L. Montaña, L. M. Pardo, A. Rojas Paredes, Quiz Games as aModel for Information Hiding, Journal of Complexity 34 1-29 (2016).

This thesis describes a computation model which is inspired in the no-tions of Information Hiding and nonfunctional requirements among otherimportant concepts in software engineering, namely, the notions of ab-straction and software design. Our computation model allows to provenontrivial and exponential lower complexity bounds for elimination algo-rithms. We show that any objectoriented (and robust) implementationof elimination algorithms is necessarily inecient. This result shows anexisting synergy between Software Engineering and Algebraic ComplexityTheory.

Keywords : Abstract data type, abstraction function, elimination al-gorithm, interpolation, information hiding, lower complexity bound, nonfunctional requirement, robustness, class diagram, computation model, objectoriented programming, polynomials, software design


Contents

1 Introduction 15

1.1 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . 181.2 Organization of the Thesis . . . . . . . . . . . . . . . . . . . 20

Introducción 23

2 Basic Concepts and Tools 27

2.1 Software Engineering . . . . . . . . . . . . . . . . . . . . . . 272.1.1 Abstract Data Type . . . . . . . . . . . . . . . . . . 272.1.2 Class . . . . . . . . . . . . . . . . . . . . . . . . . . . 282.1.3 Features, Routines and Abstract Data Type Functions 312.1.4 Abstraction Function . . . . . . . . . . . . . . . . . . 312.1.5 NonFunctional Requirements . . . . . . . . . . . . . 322.1.6 Information Hiding . . . . . . . . . . . . . . . . . . . 342.1.7 ObjectOriented Programming . . . . . . . . . . . . 34

2.2 Eective Algebraic Geometry . . . . . . . . . . . . . . . . . 362.2.1 Polynomial Equation Solving . . . . . . . . . . . . . 392.2.2 Arithmetic Circuits . . . . . . . . . . . . . . . . . . . 39

2.3 Computational Complexity Theory . . . . . . . . . . . . . . 402.3.1 Lower Complexity Bounds . . . . . . . . . . . . . . . 402.3.2 Computation Models and Software Engineering . . . 42

Conceptos y Herramientas Básicas 45

3 Preliminary Computation Models 47

3.1 Elimination in Terms of Abstract Data Types . . . . . . . . 473.2 CircuitBased Elimination Algorithms . . . . . . . . . . . . 543.3 Robust Elimination Algorithms . . . . . . . . . . . . . . . . 59

Modelos de Cómputo Previos 65

4 Quiz Games Computation Model 67

4.1 ObjectOriented Elimination . . . . . . . . . . . . . . . . . . 674.2 Quiz Game: a Model for Information Hiding . . . . . . . . . 69

Modelo de Cómputo Quiz Games 75

5 Selected Lower Complexity Bounds 79

5.1 Polynomial Interpolation . . . . . . . . . . . . . . . . . . . . 795.1.1 Interpolation and Numerical Analysis . . . . . . . . . 795.1.2 Multivariate Polynomial Interpolation . . . . . . . . . 805.1.3 Univariate Polynomial Interpolation . . . . . . . . . . 84

5.2 Elimination . . . . . . . . . . . . . . . . . . . . . . . . . . . 87


5.2.1 A Parameterized Family of Projections of a Hypercube 875.3 Other Applications . . . . . . . . . . . . . . . . . . . . . . . 95

5.3.1 Neural Networks with Polynomial Activation Functions 955.3.2 Applications in Software Engineering . . . . . . . . . 98

Cotas Inferiores de Complejidad 101

6 Approximative Algorithms and

Concluding Remarks 103

6.1 Approximative Algorithms . . . . . . . . . . . . . . . . . . . 1036.1.1 Approximative Parameter Instances . . . . . . . . . . 1036.1.2 The Protocol of the Approximative Quiz Game . . . 104

6.2 Concluding Remarks . . . . . . . . . . . . . . . . . . . . . . 107

Algoritmos Aproximativos y Conclusión 109

A The Identity Function which Change

the Representation 121

B Tools from Algebraic Geometry 123

B.1 Notions and Notation from Algebraic Geometry . . . . . . . 123B.2 Geometrically Robust Constructible Maps . . . . . . . . . . 124

C Polynomials which are Easy to Evaluate 125


List of Figures

1 Leopold Kronecker, pioneer in elimination algorithms. . . . . . . 152 Evolution of elimination algorithms complexity. . . . . . . . . . 173 Algorithms and its model. . . . . . . . . . . . . . . . . . . . . 194 Our computation model captures two languages . . . . . . . . . 205 An array implementation of stacks. . . . . . . . . . . . . . . . 306 A basic design for stacks. . . . . . . . . . . . . . . . . . . . . . 307 Functions and Features. . . . . . . . . . . . . . . . . . . . . . 328 Abstraction function (gure from [Mey97]). . . . . . . . . . . . 339 Robustness complements correctness (gure from [Mey97]). . . . 3310 Function size and the body of routine size. . . . . . . . . . . . 3511 Objectoriented implementation of function size. . . . . . . . . 3612 The hyperbolic paraboloid and its dening polynomial equation. 3713 Kronecker algorithm logo. . . . . . . . . . . . . . . . . . . . . 3914 An arithmetic circuit and its straight line program. . . . . . . . 4015 Complexity classes. . . . . . . . . . . . . . . . . . . . . . . . . 4116 Computation realized by a person, the origin of Turing machine. 4217 Elimination algorithm as a function solve. . . . . . . . . . . . . 5018 Class Poly and its mathematical model. . . . . . . . . . . . . . 5019 A preliminary model for routine solve. . . . . . . . . . . . . . 5120 A more suitable model for routine solve. . . . . . . . . . . . . 5321 Basic design behind elimination algorithms. . . . . . . . . . . . 5422 Choice of representation Slp and abstract data type Poly. . . . . 5523 Routine solve and its mathematical model. . . . . . . . . . . . 5524 Map csolve in terms of arithmetic circuits β and γ. . . . . . . . 5625 Two dierent framed data structures for OD. . . . . . . . . . . 5726 Abstraction functions ω and ω′. . . . . . . . . . . . . . . . . . 5827 Software engineering robustness and geometrical robustness. . . 6028 Reparametrization of framed data structure N . . . . . . . . . . 6229 Geometrically robust abstraction functions θ and θ′. . . . . . . . 6230 Parameterized model for robust circuitbased elimination. . . . . 6331 Function solve as an objectoriented algorithm. . . . . . . . . . 6832 Mathematical model for objectoriented elimination. . . . . . . 6933 A pair of abstraction functions θi and θj . . . . . . . . . . . . . 7134 Función solve como un algoritmo orientado a objetos. . . . . . . 7535 Modelo matemático para la eliminación orientada a objetos. . . . 7636 Objectoriented implementation of function identity. . . . . . . 8037 Hidden representation u and new representation v∗. . . . . . . . 8138 A quiz game for interpolation. . . . . . . . . . . . . . . . . . . 8239 A quiz game for map τ ′D. . . . . . . . . . . . . . . . . . . . . . 8640 An example of objectoriented elimination. . . . . . . . . . . . 8941 Two kinds of polynomial evaluation. . . . . . . . . . . . . . . . 92


42 An interesting framed abstract data type carrier of polynomials. 9343 An unexpected winning strategy. . . . . . . . . . . . . . . . . . 9444 A neural network. . . . . . . . . . . . . . . . . . . . . . . . . 9545 Learning function θ(t, u). . . . . . . . . . . . . . . . . . . . . . 9646 Two designs for the membership problem of nite sets. . . . . . 9847 Our model evaluates a software design. . . . . . . . . . . . . . 9948 Quiz game for an approximative algorithm. . . . . . . . . . . . 10549 Quiz game para un algoritmo aproximativo. . . . . . . . . . . . 10950 Arithmetic circuit evaluating G∗. . . . . . . . . . . . . . . . . . 12651 Arithmetic circuit evaluating F ∗. . . . . . . . . . . . . . . . . . 127


1 Introduction

According to the computer algebra handbook [GKW03], quantier elimi-nation is an important topic of algorithmic commutative algebra. In thisthesis we study the special case of the elimination of a single existentialquantier block from the point of view of eective algebraic geometry, theeld of mathematics which studies zeros of multivariate polynomials. Inthe sequel we refer to the computer programs which solve this problem aselimination algorithms.

The computational eciency of elimination algorithms has received am-ple research attention since Leopold Kronecker's rst approach in 1882 (see[GH01] for a comprehensive analysis of Kronecker's work).

Figure 1: Leopold Kronecker, pioneer in elimination algorithms.

From a practical aim, the eciency of elimination algorithms has greatimportance for scientic computing, computer algebra and polynomial equa-tion solving (see e.g. the applications described in [Bru98], [LW01] and[DE10]). On the other hand, from a theoretical aim, the complexity statusof elimination algorithms has great importance for computational com-plexity theory since an instance of the knapsack problem is a special inputwhere we can apply elimination algorithms ([HM93] and Example 7 in Sec-tion 2.2).

Among the main modern achievements concerning the eciency of elim-


ination algorithms are the works of Noaï Fitchas1 and TERA2. A key factorfor the eciency of elimination algorithms is the implementation of poly-nomials. This factor aected considerably the evolution of elimination al-gorithms complexity, e.g., rst elimination algorithms (around 1980) usingpolynomials given by coecients (dense and sparse representation) werenot ecient, its complexity was doubly exponential, say

sO(1)dnO(n)

(1)

where d is the degree of the system, s is the number of polynomials deningit, and n is the number of variables to be eliminated (see [Pud95] for a sur-vey on rst elimination algorithms). This complexity was later reduced tothe simply exponential sO(1)dO(n2) by means of the Eective Nullstellensatz(see [Kol88] and [Som99]). In 1992, a new data structure produced con-siderable progress, polynomials were implemented by means of arithmeticcircuits evaluating them, this new data structure reduced the complexityto

sO(1)dO(n). (2)

First elimination algorithms using arithmetic circuits were probabilisticand hybrid, i.e., outputs were in arithmetic circuit representation, whereasinputs were still in coecient representation. This hybrid characteristicwas later improved by a polynomial equation system solver which imple-ments all polynomials including the input in terms of arithmetic circuits.This solver, called Kronecker, reduced the complexity (2) to the pseudo-polynomial

δ2(snd)O(1) (3)

where δ is a discrete semantic parameter which in worst case may becomedn (see [GLS01]). Figure 2 below illustrates this evolution of eliminationalgorithms complexity.

1Noaï Fitchas is the collective pseudonym of a group of argentinian mathematicianswhose contributions in commutative algebra and eective algebraic geometry promotedan international research on issues of symbolic computation complexity. The originalmembers were Leandro Caniglia, Guillermo Cortiñas, Silvia Danón, Teresa Krick andPablo Solernó. This group was founded in 1987 by Joos Heintz in the aim to obtaina collective genius, according to Heintz, it is infeasible to nd a genius like Gauss buta group of persons could complete each other to create a genius. The name of thegroup makes reference to the in those years popular message no hay chas in any kioskin Buenos Aires. The center of operations of Noaï Fitchas was Instituto Argentinode Matemática, CONICET, Viamonte 1636 (1055) and Facultad de Ciencias Exactas yNaturales, Dpto. de Matemática, Ciudad Universitaria (1428), Buenos Aires, Argentina.

2Since 1991, the group Noaï Fitchas had a gradual reorientation of its scientic ac-tivities towards technologically relevant results. The result of this reorientation wasthe International Group TERA (Turbo Evaluation and Rapid Algorithms, [Ter]), re-search and development of software for the simplication of systems of polynomial andalgebrodierential equations.


1980 1984 1988 1992 1996 2000 2004

sO

(1) dnO(n) an

dcoecients

sO

(1) dO

(n2 ) an

dEectiveNullstellensatz

sO

(1) dO

(n) an

darithmeticcircuits

δ2 (snd

)O

(1) an

dKroneckeralgorithm

Figure 2: Evolution of elimination algorithms complexity.

While the complexity of elimination algorithms was improved consider-ably due to circuitbased approaches since 1992, the current pseudopoly-nomial complexity of Kronecker algorithm raise the question whether thiscomplexity may be improved. A classic strategy to answer this kind of ques-tions consists of obtaining lower complexity bounds, e.g., an exponentiallower bound would indicate that Kronecker algorithm is already optimal,i.e., there is no (and there will not be) faster algorithms. In order to obtainsuch lower bounds we have to dene a computation model which denes thealgorithms we are considering and a suitable complexity measure. Thereare several approaches to dene a computation model for elimination algo-rithms, e.g., it may be required that arithmetic circuits are nite dynamicsets, namely data structures which can grow arbitrarily (see e.g. Cormen'sbook [CLRS09]). Thus, one of our main goals is to carry out a computationmodel which considers the most important points a programmer takes intoaccount (in real life) in order to solve elimination problems. Which arethose points and should we model all of them?

The main purpose of this work is to present a new computation modelwhich allows us to respond previous questions. To this end, our modelcaptures the art of software engineering, this characteristic distinguishesour model from classical computation models such as the Turing machine(see [Tur36] and [DSW94]) or algebraic models ([SS95]), and allows usto give lower complexity bounds for elimination algorithms produced bysoftware engineering.

In this work we describe three studies conducted between July 2011 andJanuary 2015 where we dened our computation model by means of themost basic and elementary notions and techniques in software engineering.Our rst step was to incorporate the notion of nonfunctional requirementas a key ingredient to obtain lower complexity bounds (preliminary versionsare [GHMS11] and [RP11]). To be precise, our model captures the non-functional requirement of robustness of elimination algorithms by means of


an algebraic characterization of the total maps whose graphs are rstorderdenable over C and continuous with respect to the Euclidean topology(the tool to carry out such a map characterization is the Zariski's MainTheorem, see e.g. [Ive73, Chapter IV.2]). We call these maps constructibleand geometrically robust.

Our second step was to generalize our model by means of category the-ory ([HKRP13a]). Although this improvement produces an elegant math-ematical formulation, category theory does not incorporate software engi-neering concepts which is our main goal. Thus, our third and last step wasto study the case when circuits become replaced by another data structure.In this scenario, the new data structure may provide an incompatible in-terface such that circuitbased algorithms would become useless. To avoidsuch a situation, a standard strategy hides the representation and workswith object-oriented elimination algorithms ([Mey97]). To capture suchalgorithms we extended our computation model with the notion of Infor-mation Hiding. We call this model Quiz Game because it is inspired in agame called VeoVeo ([Veo]) which may be formally expressed by means ofInteractive ProofSystems ([GMR85]).

Our circuitbased computation model allows us to give exponentiallower complexity bounds for general, robust and circuitbased elimina-tion algorithms. This result suggests an intrinsic diculty to improve thecomplexity of Kronecker algorithm and circuitbased approaches. On theother hand, our Quiz Games suggest the same exponential lower complexitybounds if we hide the representation of polynomials and we consider objectoriented elimination algorithms. This result was published in [BHM+16]where there is a generalization of our model to approximative eliminationalgorithms. However, we do not include in this thesis all the items of[BHM+16], e.g., certain lower complexity bounds for linear algebra prob-lems, and we focus our attention in the relationship with software engineer-ing. Thus, our intended audience is the software engineering communitywho we hope will accept our descriptions as natural and standard, in sucha case, one of our main goals is done. In this sense, the present work sug-gests a novel contribution to software engineering foundations and showsthat nontrivial methods from algebraic geometry can be used with successin a computer science discipline.

1.1 Methodology

In this thesis we study algorithms which are produced by means of softwareengineering techniques and we capture them within a mathematical model.Such a model allows us the application of mathematical tools in order toobtain conclusions which must be re-traduced to the original computerscience context. Figure 3 below illustrates this idea.


algorithm produced bySoftware Engineering

Mathematical computation model

modeling Software Engineering →

← traducing mathematical results

Figure 3: Algorithms and its model.

Figure 3 above may be described in the following terms. The left sideof the gure represents a syntactical computer science language, whereasthe right side of the gure represents a semantic mathematical model weare going to develop in this thesis.

Observe that Figure 3 above also includes the diculty of obtaining asuitable model: it is not expected that a very specic model of a computerscience problem may produce great mathematical conclusions which in turnlead to surprising and unknown computer science inferences. On the otherhand, a general mathematical model would allow only general and trivialresults for computer science. Another diculty appears when the prob-lem we consider is addressed by the emerging eld of software engineeringwhere standards and mathematical foundations are immature according todescriptions in the Semat Kernel (see [JNM+12]). Thus, in order to obtaina suitable model, this thesis focuses on the tuning of the model, e.g., seeSections 3 and 4 where our computation model is dened in a gradual wayand we describe at each step the tuning we carry out.

The computation model we are going to dene in this thesis can be de-scribed in terms of the languages we study. To be precise, our computationmodel have to deal with two levels of language, namely, a level of abstractconcepts like the language of software engineering given by data struc-tures, nonfunctional requirements and software given by objectorientedprogramming, and, on the other hand, the language of the concrete exam-ples we study in this thesis, namely arithmetic circuits, geometrical robust-ness and elimination algorithms. Figure 4 illustrates the correspondencebetween these two languages3.

Dear reader, keep in mind Figures 3 and 4 which may become usefultools to understand the notions, concepts and relationships we study inthis thesis.

3We thank Hvara Ocar who suggested the elaboration of Figure 4. This gure wasan important tool to organize and communicate ideas at the beginning of our research.


data structures

nonfunctionalrequirements

software

arithmetic circuits

geometrical robustness

elimination algorithm

abstract concepts concrete examples

Figure 4: Our computation model captures two languages

1.2 Organization of the Thesis

This thesis is composed by six sections and two appendices, including thisintroductory section. In Section 2 we recall denitions, concepts and nota-tions from Software Engineering, Algebraic Geometry and ComputationalComplexity Theory.

The exposition of our own work starts with Section 3 where we discusspreliminary versions of our computation model. The mathematical andcomplexity theoretical aspects of this thesis are mainly based in [GHMS11]and [HKRP13b], where the authors used their own terminology. Here wepresent previous results from a dierent point of view, the dierence con-sisting mainly of the language which we adopt in this thesis. We standardizethe terminology of [HKRP13b] by means of concepts taken from objectoriented programming in the spirit of B. Meyer [Mey97]. We carry out astrict distinction between the concepts of algorithm and our mathematicalmodel. This distinction leads us to the formulation of a computation modelwhich captures robust and circuitbased elimination algorithms.

In Section 4 we introduce our new computation model which capturesthe notion of Information Hiding. We use our model, called Quiz Game,in Section 5 where we exhibit an innite family of simple elimination prob-lems whose computational solution in our model requires (objectoriented)algorithms of exponential time complexity. We also exhibit an applicationin machine learning, we found a lower bound for the eciency of neuralnetworks with polynomial activation functions. We nish this section witha discussion of our model as a tool for software design analysis.


Section 6 is devoted to approximative elimination algorithms and con-clusions.

We nish this thesis with Appendix A where we present the rst exam-ple which motivated the development of our quiz game, and Appendix Cwhich contains the notions, notations and correctness proof from algebraicgeometry discussed in this work.


Introducción

De acuerdo con el manual de álgebra computacional [GKW03], la elimi-nación de cuanticadores es un tema importante del álgebra conmutativaalgorítmica. En esta tesis se estudia el caso especial de la eliminación deun solo bloque de cuanticadores existenciales desde el punto de vista de lageometría algebraica efectiva, el campo de la matemática que estudia cerosde polinomios multivariados. En lo que sigue nos referimos a los programasinformáticos que solucionan este problema como algoritmos de eliminación.

La eciencia computacional de los algoritmos de eliminación ha recibidouna amplia atención por parte de la comunidad cientíca desde los primerosestudios realizados por Leopold Kronecker en 1882 (ver [GH01] para unanálisis exhaustivo del trabajo de Kronecker).

Desde un objetivo práctico, la eciencia de los algoritmos de eliminacióntiene gran importancia para el cálculo cientíco, el álgebra computacionaly la resolución de ecuaciones polinomiales (ver las aplicaciones descritasen [Bru98], [LW01] y [DE10]). Por otro lado, desde un objetivo teórico,la complejidad intrínseca de los algoritmos de eliminación tiene gran im-portancia para la teoría de la complejidad computacional, en efecto, unainstancia del problema de la mochila es un caso especial donde podemosaplicar algoritmos de eliminación (ver [HM93] y Ejemplo 7).

Entre los principales logros modernos en lo que respecta a la eciencia delos algoritmos de eliminación se encuentran los trabajos de Noaï Fitchas yTERA. Un factor clave para la eciencia de los algoritmos de eliminación esla implementación de polinomios. Este factor inuyó considerablemente laevolución de la complejidad de los algoritmos de eliminación, por ejemplo,los primeros algoritmos de eliminación (alrededor de 1980) que utilizabanpolinomios dados por coecientes (representación densa y rala) no eranecientes, su complejidad era doblemente exponencial:

sO(1)dnO(n)

(4)

donde d es el grado del sistema, s es el número de polinomios que lo de-nen, y n es el número de variables a eliminar (ver [Pud95] para un re-sumen sobre los primeros algoritmos de eliminación). Esta complejidadse redujo posteriormente a simple exponencial (cuadrática) sO(1)dO(n2) pormedio del Nullstellensatz efectivo (ver [Kol88] y [Som99]). En 1992, unanueva estructura de datos produjo un progreso considerable, se implemen-taron polinomios mediante circuitos aritméticos, esta nueva estructura dedatos redujo la complejidad a:

sO(1)dO(n). (5)

Los primeros algoritmos de eliminación que utilizaban circuitos aritméticoseran probabilísticos e híbridos, i.e., las salidas de los algoritmos estaban en


representación de circuitos aritméticos, mientras que las entradas estabantodavía en representación dada por coecientes. Esta característica híbridafue mejorada posteriormente por un solver de sistemas de ecuaciones poli-nomiales, que implementa todos los polinomios incluyendo la entrada entérminos de circuitos aritméticos. Este solver, llamado Kronecker, redujola complejidad (5) a la complejidad pseudopolinomial:

δ2(snd)O(1) (6)

donde δ es un parámetro semántico discreto que en el peor caso puede llegara ser dn (ver [GLS01]).

Si bien la complejidad de los algoritmos de eliminación ha mejorado con-siderablemente debido a los enfoques basados en circuitos aritméticos desde1992, la complejidad pseudopolinomial actual del algoritmo de Kroneckerplantea la cuestión de si esta complejidad puede mejorarse. Una estrategiaclásica para responder a este tipo de preguntas consiste en obtener cotas in-feriores de complejidad, por ejemplo, una cota inferior exponencial indicaríaque el algoritmo de Kronecker ya es óptimo, i.e., no hay (y no habrá) algo-ritmos más rápidos. Para obtener tales cotas inferiores debemos denir unmodelo de cómputo que dena los algoritmos que estamos considerando yuna medida de complejidad adecuada. Existen varios enfoques para denirun modelo de cómputo para algoritmos de eliminación, por ejemplo, puedeser necesario que los circuitos aritméticos sean conjuntos dinámicos ni-tos, i.e, estructuras de datos que pueden crecer arbitrariamente (ver, porejemplo, Cormen's book [CLRS09]). Nuestro principal objetivo es realizarun modelo computacional para algoritmos de eliminación que considere lospuntos más importantes que un programador tiene en cuenta (en la vidareal) para resolver un problema computacional dado.

El propósito principal de este trabajo es presentar un nuevo modelode cómputo que nos permita responder las preguntas anteriores. Para ello,nuestro modelo capta el arte de la Ingeniería de Software, esta característicadistingue nuestro modelo de modelos de cómputo clásicos como la máquinade Turing ([Tur36], [DSW94]) ó modelos algebraicos ([SS95]), y nos per-mite dar cotas inferiores de complejidad para los algoritmos de eliminaciónproducidos por la Ingeniería de Software.

En este trabajo se describen tres estudios realizados entre julio de 2011y enero de 2015 donde se denió nuestro modelo de cómputo mediante lasnociones y técnicas más elementales en Ingeniería de Software. Nuestroprimer paso fue incorporar la noción de requerimiento nofuncional comoun ingrediente clave para obtener cotas inferiores de complejidad (las ver-siones preliminares son [GHMS11] y [RP11]). Para ser precisos, nuestromodelo captura el requerimiento no funcional de la robustez de los algorit-mos de eliminación mediante una caracterización algebraica de las funcionestotales cuyos grácos son de primer orden denibles sobre C y continuos


con respecto a la topología de Euclides, la herramienta para realizar talcaracterización de funciones es el Teorema Principal de Zariski (ver [Ive73,Capítulo IV.2]). Llamamos a estos mapas constructivos y robustos desdeel punto de vista geométrico.

Nuestro segundo paso fue generalizar nuestro modelo por medio de lateoría de categorías (ver [HKRP13a]). Aunque esta mejora produce unaformulación matemática elegante, la teoría de categorías no incorporó eneste caso nuevos conceptos de Ingeniería de Software, nuestro principalobjetivo. Por lo tanto, no incluimos en esta tesis dicho trabajo sobre cate-gorías. Nuestro tercer y último paso fue estudiar el caso en donde los cir-cuitos son reemplazados por otra estructura de datos. En este escenario, lanueva estructura de datos puede proporcionar una interfaz incompatible detal manera que los algoritmos basados en circuitos se vuelvan inútiles. Paraevitar esta situación, una estrategia estándar consiste en ocultar la repre-sentación y trabajar con algoritmos de eliminación dentro del paradigmaorientado a objetos ([Mey97]). Para capturar tales algoritmos, ampliamosnuestro modelo de cómputo con la noción de ocultamiento de la informa-ción. Llamamos a este modelo Quiz Game porque está inspirado en unjuego llamado VeoVeo ([Veo]) que se puede expresar formalmente medi-ante Interactive ProofSystems ([GMR85]).

Nuestro modelo de cómputo basado en circuitos nos permite dar co-tas inferiores de complejidad exponenciales para algoritmos de eliminacióngenerales, robustos y basados en circuitos. Este resultado sugiere una di-cultad intrínseca para mejorar la complejidad del algoritmo Kronecker y losenfoques basados en circuitos. Por otro lado, nuestro modelo Quiz Gamesugiere los mismos límites exponenciales de menor complejidad si ocultamosla representación de polinomios y consideramos algoritmos de eliminacióndentro del paradigma orientado a objetos. Este resultado fue publicado en[BHM+16] donde hay una generalización de nuestro modelo a algoritmos deeliminación aproximativos. Sin embargo, no incluimos en esta tesis todoslos elementos de [BHM+16], por ejemplo, ciertas cotas inferiores de com-plejidad para problemas de álgebra lineal, y enfocamos nuestra atenciónen la relación con la Ingeniería de Software. Por lo tanto, nuestro públicoobjetivo es la comunidad de Ingeniería de Software. Esperamos que estacomunidad acepte nuestras descripciones como naturales y estándar, en talcaso, uno de nuestros principales objetivos se cumpliría. En este sentido,el presente trabajo sugiere una contribución a las bases formales de Inge-niería de Software y muestra que los métodos no triviales de la geometríaalgebraica se pueden utilizar con éxito en una disciplina de informática.


2 Basic Concepts and Tools

In this section we collect basic concepts and tools from software engi-neering, eective algebraic geometry and computational complexity theory.Software engineering provides the concepts which support and justify ourcomputation model. Eective algebraic geometry contains elimination al-gorithms, and provides the mathematical tools to dene our computationmodel. Finally, computational complexity introduces the basic notions tostudy the complexity of algorithms, e.g., lower complexity bounds.

2.1 Software Engineering

In this section we describe the terminology we borrow from Bertrand Meyer'sbook Objectoriented software construction ([Mey97]).

2.1.1 Abstract Data Type

An abstract data type (ADT) is a mathematical concept also called a type,which provides a high level description mechanism free of implementationconcerns. An abstract data type is a collection of objects characterizedby functions, axioms and preconditions. Abstract data type functions,called functions are mathematical functions applicable to the instances ofthe abstract data type. An instance of an abstract data type is a purelymathematical element.

An abstract data type is described by an abstract data type specicationwhich consists of four paragraphs, namely TYPES, specifying the nameof the abstract data type; FUNCTIONS, specifying the list of functionsapplicable to instances of the abstract data type; AXIOMS, expressingpredicates about function properties; and PRECONDITIONS where thedomain of partial functions is specied. The following example illustratesthe notion of abstract data type.

Example 1 (Abstract data type specication for stacks).

• TYPES: STACK[G]

• FUNCTIONS:

put: G×STACK[G]→STACK[G] (command function)

remove: STACK[G] 6→STACK[G] (command function)

item: STACK[G] 6→G (query function)

empty: STACK[G]→BOOLEAN (query function)

new: →STACK[G] (creator function)

• AXIOMS: for any x ∈ G, s ∈ STACK[G]

A1 item(put(x,s))=x


A2 remove(put(x,s))=s

A3 empty(new)=true

A4 empty(put(x,s))=false

• PRECONDITIONS:

remove(s) requires not empty(s)

item(s) requires not empty(s)

In the expression `STACK[G]', the letter G denotes an arbitrary un-specied type G which generalizes the type of stack elements.

The FUNCTIONS paragraph lists the operations applicable to instancesof STACK[G]. This paragraph does not fully dene functions; it only in-troduces their signatures (the list of their argument and result types), e.g.,the signature of function put is G×STACK[G] →STACK[G] and indicatesthat two arguments are accepted: an instance of G and an instance ofSTACK[G], and yields as result a new instance of STACK[G] (with oneextra element pushed on top). Similarly, the signature of functions removeand item introduces a crossed arrow 6→ which expresses that the functionis partial, e.g., it has no sense to apply function remove to an empty stack.A special case in FUNCTIONS paragraph is the function new which has noarguments, function new is a constant function which always returns theempty stack.

The AXIOMS paragraph states stack properties, e.g., the rst two ax-ioms express the basic LIFO (lastin, rstout) property of stacks. AxiomsA3 and A4 tell us when a stack is empty and when it is not.

The PRECONDITIONS paragraph states the domain of partial func-tions, e.g., the precondition of remove expresses that the stack argumentmust be nonempty.

2.1.2 Class

A class is an abstract data type equipped with implementation, to be pre-cise, a class is software text composed by two parts: a public part composedby the abstract data type specication and a private part composed by achoice of representation. In the public part abstract data type functionsare implemented in terms of the choice of representation. These implemen-tations are called features and are operations applicable to the instancesof the class, called objects. An object is a dynamically created data struc-ture, existing only in the memory of a computer during the execution of aprogram.

A class may play two roles: module or type. As a type a class is asemantic concept, namely, a collection of objects characterized by applica-ble functions (notice that this denition is similar to that of abstract data


types), whereas as a module, a class is a syntactic concept which aectsthe form of the software text, see e.g. class Stack[G] in Example 2 below.

Example 2 (Class Stack[G]). This example was taken from [AHU83] andwas adapted to Meyer's notation. Our example describes an array imple-mentation of stacks of xed capacity where an integer called top indicatesthe current position in the array of the rst stack element. Figure 5 belowdescribes this implementation.

The following software text in Eiel programming language (the lan-guage used in our main reference book [Mey97]) implements the abstractdata type STACK[G] described in Example 1 above.

Class Stack[G]

feature - - public features:

put(x:G) is - - implements command function put

(constructor)

require not(top==1) - - stack is not full

do

top:=top-1;

elements[top]:=x;

end

remove is - - implements command function remove

(constructor)

require not(empty)

do

top:=top+1;

end

item:G is - - implements query function item (observer)

require not(empty)

do

Result:=elements[top];

end

empty:Boolean is - - implements query function

empty (observer)

do

if(top > elements.size()) then

Result:=false;

else

Result:=false;

end


new(capacity:Integer) is - - creator function

new (constructor)

do

!!elements.make(1,capacity);

top:=capacity+1 ;

end

feature None - - private features:

top:Integer; - - choice of representation

elements:Array[G];

end

Figure 5: An array implementation of stacks.

An objectoriented system is a structured collection of classes wherethe main interclass relations are the inheritance and client relation. e.g.,the following class diagram in UML notation (see e.g. [Mey97], [LG00] and[BRJ99]) illustrates the array implementation of stacks described before.Observe that the interclass relation between stack and array and integerbecomes illustrated by a bold arrow called UML composition. We are goingto use extensively this kind of diagrams along this thesis.

Stack

Array Integer

Figure 6: A basic design for stacks.


2.1.3 Features, Routines and Abstract Data Type Functions

Abstract data type functions or simply functions are classied into creators,commands and queries. Creators are functions which produce instances ofthe current type from instances of other types. Commands are functionswhich yield new instances of the abstract data type from existing instancesof the same abstract data type. Queries are functions which yield propertiesof the current instance of the abstract data type.

In order to illustrate the notions of creators, queries and commands,consider Example 1 of stacks above. The function new is a creator functionbecause this function returns without parameters a new instance of abstractdata type STACK[G]. The function put is a command function because itreturns, from an instance of G and an instance of STACK[G], a new instanceof STACK[G] with the instance of G pushed on top. The function empty isa query function because it returns a Boolean indicating whether the stackis empty.

An alternative terminology pointed by Meyer states that creators areconstructors , queries are accessors and commands are modiers. Anotheralternative terminology, which is frequently used in undergraduate coursesof algorithms and data structures states that creators and commands areconstructors and queries are observers. Figure 7 below illustrates theseterminologies.

On the other hand, a class provides features which are the softwarecounterpart of functions. Features are classied into attributes and rou-tines. Attributes are eld of objects, e.g., the variable top in Example 2above which indicates the top element of the stack. Routines are compu-tations on objects and are sub-classied into:

• functions (routines which return a result), e.g., routines item andempty in Example 2, and

• procedures (routines which do not return a result), e.g., routines putand remove in the same example.

In the objectoriented programming language Smalltalk, attributes areinstance variables and routines are methods.

Figure 7 below illustrates the connection between features and func-tions. The counter part of creator functions is an operation called creationprocedure, the counter part of command functions are procedure routines,and the counter part of query functions are function routines. Observe thatExample 2 above illustrates the features which compose class Stack[G].

2.1.4 Abstraction Function

A class describes one possible implementation for an abstract data type, thecorrespondence between this implementation and the abstract data type is


Figure 7: Functions and Features.

expressed by the abstraction funcion, which for any instance of the class(object) yields the instance of the abstract data type that it represents.Observe that an abstraction function is not a map

class→ abstract data type,

because a class is an abstract data type equipped with a choice of represen-tation. Thus, a precise description suggests that an abstraction function isa map

choice of representation→ abstract data type.

Now we may consider the following example taken from [Mey97] whichillustrates the notion of abstraction function.

Example 3 (Abstraction function). Let A be an abstract data type, let Cbe a class implementing A. Let ABST_1 and ABST_2 be two instancesof the abstract data type A. Let CONC_1 and CONC_2 be two instancesof the class C (objects). Let af be a function of the abstract data type A.Let cf be a routine in the class C. Then the abstraction function a mapsconcrete object into abstract objects as Figure 8 illustrates.

The implementation cf is correct if the diagram is commutative, that isto say cfa=aaf.

2.1.5 NonFunctional Requirements

A nonfunctional requirement is a software property not described in thefunctional specication (see e.g. [CNYM12]), e.g., an special subset of nonfunctional requirements are the quality attributes described in [BCK98],


Figure 8: Abstraction function (gure from [Mey97]).

namely, performance, modiability, security, usability, availability and testa-bility. According to Meyer's terminology this kind of properties is calledquality factors and the main examples are correctness, robustness, ex-tendibility, reusability and eciency among others.

In this thesis we are interested in correctness, robustness, performanceand eciency. These nonfunctional requirements will be important ingre-dients in our computation model.

Correctness According to [Mey97] correctness is the ability of softwareproducts to perform their exact tasks as dened by their specication.

Robustness According to [Mey97] robustness is the ability of a softwaresystem to react appropriately to abnormal events which occur during theexecution of the given software system. Such abnormal events are casesnot covered by the specication. In this sense, robustness complementscorrectness. Figure 9 below illustrate this idea.

Figure 9: Robustness complements correctness (gure from [Mey97]).

An alternative denition given by Liskov ([LG00]) states that a robustprogram continues to behave reasonably even in the presence of errors. No-tice that errors in Liskov's denition may be compared to cases not coveredby the specication in Meyer's denition. In this sense both denitions fora robust program are equivalent.

Another denition of robustness which is closer to the notion of contin-uous function states that in a robust program, small perturbations in the


inputs do not have much eect on the outputs ([CGL12]). In the sequel weargue that continuity is a special case of robustness and becomes a requiredand desirable property of elimination algorithms.

2.1.6 Information Hiding

The relationship between components of the software and the structure ofthe whole system is described by the software architecture. The processof identifying components, modules and partitions for a suitable softwarearchitecture gives rise to the concept of information hiding which is thecriteria to construct maintainable software by means of hiding implemen-tation details or hiding parts of the system that may change (see [Par72]).

A more precise denition is given by [Mey97] where information hidingis the mechanism which makes certain features of a given class unt forother classes (called client classes), these features are part of the choice ofrepresentation which is used for internal purposes only, namely, to imple-ment the features which are part of the public interface of the class (seee.g. Example 2).

2.1.7 ObjectOriented Programming

In this section we introduce the notion of objectoriented programming bymeans of an example in terms of stacks. To this end we have to distinguishbetween a routine, the internal instructions of the body of a routine andhow the class and its features may be used by client classes in order tosolve a given computation task.

Let us extend abstract data type STACK[G] of Example 1 with a queryfunction (observer) called size which returns the number of elements con-tained in the stack. The following routine is a suitable implementation offunction size in terms of the choice of representation given by the classesArray[G] and Integer (Example 2).

Example 4 (Routine size).

size:Integer is - - returns the number of elements

in the stack

do

Result:= (elements.size()+1)-top;

end

Let us denote the abstract data type behind class Stack[G] with a boxlabelled STACK[G], and the abstract data types behind classes Array[G]and Integer with boxes labelled ARRAY[G] and INTEGER respectively.Thus, we may graphically denote function size with an arrow connectingboxes ARRAY[G] and INTEGER. On the other hand, we may suppose


that there exists an abstraction function abs which connects the instancesof the choice of representation with the corresponding instance of the ab-stract data type STACK[G]. We may denote the choice of representationwith a box labelled (ARRAY[G], INTEGER), then the abstraction func-tion becomes an arrow connecting boxes (ARRAY[G], INTEGER) andSTACK[G]. Similarly, we may graphically denote the body of routine sizewith an arrow connecting boxes (ARRAY[G], INTEGER) and STACK[G].Figure 10 below illustrates this description.

STACK[G] size // INTEGER

ARRAY[G], INTEGER

abs

OO

body of routine size

99

Figure 10: Function size and the body of routine size.

Observe that Figure 10 is a semantical and mathematical model for thesyntactical model given by class diagram we described before in Figure 6 .We can compare both gures and observe that routine size is contained inclass Stack[G] and therefore belongs to the software text, while functionsize belongs to the world of abstract data types which are mathematicalsets.

Let us consider now the following alternative implementation of functionsize.

Example 5 (Objectoriented routine size).

size(s:Stack[G]):Integer is

do

count:= 0;

while(not(s.empty()))

s.remove();

count:=count+1;

Result:= count;

end

The basic mechanism of objectoriented computation is the feature callor dot notation which applies a feature of a class to an object.

Observe that the body of routine size in Example 5 above is a com-position of other routines, namely routines empty and remove from class


Stack[G] and the sum operation of class Integer. This composition ofroutines is carried out by means of the basic mechanism of objectorientedcomputation, namely the feature call which consists in applying to an in-stance of a class a feature of that class. e.g., the instruction s.remove()means that we apply the routine remove() to the stack instance s. Smalltalkprogrammers would say pass to the object s the message remove() withoutarguments.

The idea behind the body of routine size in Example 5 above is toincrement a counter every time we remove an element of the stack, if wereach a point where there is no elements to remove we have the size. Sincethere is a direct correspondence between routines and abstract data typefunctions, we may suppose that there exists a composition of creators andcommands (constructors) of the abstract data type INTEGER and queries(observers) of the abstract data type STACK[G] such that this compo-sition corresponds to the composition of routines in the body of routinesize. Thus, we have a mathematical model (a composition of abstractdata type functions) for a composition of routines implementing anotherroutine (routine size). We call the obtained composition of abstract datatype functions an objectoriented implementation of function size. Figure11 below illustrates this objectoriented implementation.

INTEGER constructorsoo STACK[G]

observersoo

object-oriented algorithm

uusize // INTEGER

ARRAY[G], INTEGER

abs

OO

body of routine size

99

Figure 11: Objectoriented implementation of function size.

From previous Example 5 we conclude Remark 6 below which will allowus to describe objectoriented elimination algorithms in Section 4.

Remark 6. A composition of functions of the abstract data type gives riseto an objectoriented algorithm.

2.2 Eective Algebraic Geometry

In this section we introduce the notion of elimination algorithm in thecontext of eective algebraic geometry.


Algebraic geometry is mainly focused in the study of algebraic varieties.An algebraic variety is the zero locus of a set of polynomials and it is usuallystudied through its dening polynomials, e.g., a set of points

x ∈ Cn | f1(x) = 0, . . . , fn(x) = 0

is called a variety dened by the polynomials f1, . . . , fn ∈ C[X1, . . . , Xn].Algebraic geometry represents the connection between two apparently

separate worlds: the geometric and the algebraic ones. The geometric worldis described by algebraic varieties, whereas the algebraic part is representedby polynomials, polynomial ideals and their quotient rings, e.g., let a, b beparameters and X, Y, Z be indeterminates, the hyperbolic paraboloid maybe dened through the polynomial equation (X

a)2 − (Y

b)2 − Z = 0. Figure

12 below illustrates this connection between geometry and algebra4.

(X

a

)2

−(Y

b

)2

− Z = 0

Figure 12: The hyperbolic paraboloid and its dening polynomial equation.

The origin of modern algebraic geometry which deals with varieties ofarbitrary dimensions dates back to the 19th century and starts with elimi-nation theory which treats the algorithmic solving of multivariate polyno-mial equation systems over the complex numbers, or more generally, overan arbitrary algebraically closed eld. This subeld of algebraic geometryis also called eective algebraic geometry.

On the other hand, consider a general problem of mathematical logicand model theory called quantier elimination. A theory has quantierelimination if for every formula Φ there exists a quantierfree formula Ψwhich is logically equivalent. This is the case of the elementary theory ofalgebraically closed elds of characteristic zero where the examples we con-sider in this thesis come from. In this case, quantier elimination is stronglyrelated to polynomial equation solving since the elimination of variables isa technique to solve polynomial equation systems. An interesting exam-ple of quantier elimination which is a particular instance of the knapsackproblem can be found in [HM93], [MSM98] and [HK04], the same problem

4Figure 12 was computed with SURFER, a software for visualization of algebraicsurfaces ([SUR]).


appears described with other names, namely, the subset sum problem in[CLRS09] or the Rucksack problem in [Bör89, C III.1]. We describe in thefollowing paragraph the connection between a decision problem like theknapsack problem and an elimination problem.

Example 7 (Elimination example). Let n ∈ N be a discrete parameter.Let X1, . . . , Xn, Y be indeterminates over C. Let Φ be the existentiallyquantied formula

Φ := (∃X1) . . . (∃Xn)(X21 −X1 = 0∧ · · ·∧X2

n−Xn = 0∧Y =∑

1≤i≤n

2i−1Xi)

and let Ψ be the quantierfree formula

Ψ := (∏

0≤j<2n

(Y − j) = 0).

Formulas Φ and Ψ are logically equivalent. In particular, formula Ψ isthe result of eliminating the quantiers in formula Φ.

Observe that Φ is the codication of a special instance of the knapsackproblem which asks whether a given number Y can be written in binaryform with n bits, or in other words, there exists a subsets of powers of2 such that its sum is the number Y . This requirement is given by theequation

Y =∑

1≤i≤n

2i−1Xi.

The complexity of this knapsack problem instance becomes reduced tothe complexity of evaluating the polynomial in formula Ψ which is calledthe Pochhammer polynomial (7) and its complexity status is still an openquestion.

∏0≤j<2n

(Y − j) (7)

Compare the Pochhammer polynomial with the following polynomialwhich has an exponential lower bound for its evaluation (see [HM93]).

∏0≤j<2n

(Y −√j) (8)

The desire to understand the similarity between (7) and (8) motivatedthe author of these lines to enter in the world of lower complexity bounds.


2.2.1 Polynomial Equation Solving

In this section we mention some approaches to polynomial equation solvingand we introduce the data structure of arithmetic circuits which is a centralingredient for the denition of our computation model.

If we have to solve a linear system, we can use Gaussian elimination,a method due to Carl Friedrich Gauss (17771855). A modern study indi-cates that Gaussalgorithms can be performed within C[X1, . . . , Xn] (see[Hei83]).

If we have to solve a nonlinear system, there exists the method of Gröb-ner Bases (also called standard bases) which allows us to solve the givensystem. Unfortunately the complexity of the algorithms using this tech-nique is dn

O(n)for systems of degree d in n variables (although according to

[FGLM93] some Gröbner Bases become computable in dO(n)). A drawbackfor this exponential complexity is the implementation of polynomials whichare given by coecients (dense and sparse representation).

An approach to deal with the complexity of polynomial equation solv-ing was to improve the algorithms and the data structures inside the algo-rithms. In this sense arithmetic circuits become an ecient representationof polynomials (see e.g. [HS81], [FIK86] and [Kal88] for the rst steps inthis direction). The rst algorithm for the resolution of polynomial equa-tion systems over algebraically closed elds which fully implements poly-nomials in terms of arithmetic circuits is the Kronecker algorithm. It wasanticipated in [GHMP95], [GHH+97], [GHM+98], [HMW01] and [GLS01],and implemented in a Magma package of identical name by Grégoire Lecerf,the last implementation called geomsolvex can be found in [Lec].

Figure 13: Kronecker algorithm logo.

Observe that the methods mentioned before are symbolic and they pro-vide exact solutions. There exist a kind of algorithms which provide ap-proximate solutions. These algorithms are based in the Newton's iterationmethod. A comparison between Kronecker's and Newton's approaches wascarried out in [CPHM01] which is the rst attempt to compare the e-ciency of symbolic and numerical analysis procedures that solve systems ofmultivariate polynomial equations.

2.2.2 Arithmetic Circuits

Let us x natural numbers i, n, and indeterminates x1, . . . , xn. An arith-metic circuit is a labelled directed acyclic graph (labelled DAG) β satisfying


the following conditions: each node of indegree zero is labelled by a complexnumber and called parameter of β or is labelled by a variable x1, . . . , xnand is called input of β. All other nodes of β have indegree two and arecalled internal. They are labelled by the arithmetic operations addition,subtraction, multiplication or division. Moreover, some nodes of β becomelabelled as outputs. We call the number of internal nodes the size of β.This number will become our main complexity measure (see e.g. Section5).

Arithmetic circuits are also called straight line programs (programswithout branching and looping instructions), e.g., the circuit from [Bun12]in Figure 14 below computes the polynomial (x1 + x2)(x2 + 42)iπ.

Figure 14: An arithmetic circuit and its straight line program.

In Section 3.3 the parameters of circuit β will become geometricallyrobust functions, we explain that this notion comes from non-functionalrequirements in Software Engineering and the resulting parametric arith-metic circuits will become robust arithmetic circuits.

2.3 Computational Complexity Theory

2.3.1 Lower Complexity Bounds

A lower complexity bound is a limit for the eciency of the algorithmswhich solve a given problem. This notion can be found e.g. in [Bor75] asan algebraic invariant which is proved for a given problem.

Lower complexity bounds were an important technique for the develop-ment of computational complexity theory when the P versus NP questionwas stated in 1971.

In those years, the discovery of the complexity class P/Poly (the classof languages decided by polynomial size circuits) was an important stepwhich produced great expectations. The KarpLipton theorem ([KL80,Theorem 6.1]) states that if NP⊂P/Poly, then the polynomialtime hierar-chy ([Sto77]) collapses. Thus, between P an NP there exists a complexityclass called P/Poly. Figure 15 illustrates these three complexity classes.


Figure 15: Complexity classes.

P/Poly was a motivation for the search of nonuniform complexitybounds. An exponential complexity lower bound for the circuit solvingan NP problem means that there exists a problem in NP which does notbelong to P/Poly. This observation would imply a solution for the rst ofthe Millennium Prize Problems which is still open.

During the writing of this thesis all this historic aspects were discoveredwhen the author was learning more about complexity, among those discov-erings we have the so called descriptive complexity which was an alternativeattempt (dierent of complexity lower bounds) to solve the P versus NPquestion. This alternative attempt characterizes the complexity classes bythe logic needed to express them, e.g., rst order logic or second order logic([EF05] and [Oca12]).

Complexity Measure According to [Bor75], in order to obtain a com-plexity lower bound we have to dene:

• rst the computation model for the algorithms we are talking about

• and then a suitable complexity measure.

Our complexity measure will not be the number of steps given by an algo-rithm as it is usual in computation models like the Turing Machine, insteadour complexity measure will be the size of the output of our programs. Inthe case of elimination algorithms where polynomials are implemented interms of arithmetic circuits this complexity measure is called Ostrowskimeasure and it is suitable to give lower complexity bounds.

Big O and Ω notation Worst case complexity will be denoted with thebig O notation, for example, O(n) is the complexity of an algorithm whichtakes in worst case linear time in the number of inputs n. On the otherhand, we use Ω notation to denote lower complexity bounds, for example,Ω(n) means that an algorithm at least takes linear time in the number ofinputs n in order to solve a problem (see [CLRS09, Chapter 3.1] for anintroduction to these notations).


Geometric Model In this thesis we study elimination algorithms ineective algebraic geometry. This kind of algorithms admits a suitablecomputation model which is justied from the point of view of softwareengineering (see Section 3). This computer science discipline is an impor-tant (and novel) aspect of our model, but not the only. The objects whichelimination algorithms deal with are of geometric nature. In this sense,the computation model we are going to dene in this thesis is a geometricmodel.

Primitive geometric models where rst applied to hardness proofs forpolynomial evaluation. A precise description of the rst works looking forfamilies of specic polynomials which are hard to compute can be found in[AHM+98].

2.3.2 Computation Models and Software Engineering

In this section we explore the theoretical notion of a computation model inthe context of the practical eld of Software Engineering.

In computational complexity theory, a computation model (or modelof computation) is a mathematical model which formalizes the notion ofcomputation in order to study the computational resources consumed bya computation process such as computation time and memory space anddiscover the inherent computational complexity of problems ([AHU74]).There are several computation models, e.g., nite states machines, randomaccess machines, Turing machines, algebraic and combinatorial circuits,among others (see e.g. [Sav98] and [Bör89]).

Figure 16: Computation realized by a person, the origin of Turing machine.

The model most used in Theoretical Computer Science is the Turingmachine which according to [BP93] models the computation realized by ahuman with pencil and paper. The person executes an algorithm by means


of writing a section of paper and passing from a mental state to another.This model clearly denes:

• a computation step,

• the time required by a computation,

• a storage unit,

• and the storage employed in a computation.

A Turing machine is a general and powerful model which captures allthe algorithms one can imagine. In this thesis we do not use Turing ma-chines, because they are general and capture all kind of algorithms. We areinterested in a specic kind of algorithms, namely, the ones professionallyproduced by software engineering rules.


Conceptos y Herramientas Básicas

En esta sección recopilamos conceptos básicos y herramientas de Ingenieríade Software, Geometría Algebraica Efectiva y Teoría de la ComplejidadComputacional.

Ingeniería de Software

La Ingeniería de Software proporciona los conceptos que nutren y justicannuestro modelo de cómputo. Desde el punto de vista de las estructurasde datos, introducimos los conceptos de tipo abstracto de datos, clase yfunción de abstracción. Desde el punto de vista de la calidad del software,introducimos los conceptos de requerimiento nofuncional, ocultamiento dela información y programación orientada a objetos.

Geometría Algebraica Efectiva

La Geometría Algebraica Efectiva contiene los algoritmos de eliminación,y proporciona las herramientas matemáticas para denir nuestro modelode cómputo. En la Sección 2.2 se ofrece un ejemplo introductorio de losproblemas de eliminación. En la Sección 2.2.1 introducimos el problema dela resolución de equaciones polinomiales y los circuitos aritméticos como laestructura de datos más utilizada en este contexto.

Complejidad Computacional

Finalmente, la Complejidad Computacional introduce las nociones básicaspara estudiar la complejidad de los algoritmos, por ejemplo, las cotas infe-riores de complejidad. En la Sección 2.3 introducimos el concepto de cotainferior de complejidad y su importancia en el contexto de los problemasmas difíciles en teoría de la complejidad. También introducimos el con-cepto general de modelo de cómputo tomando como ejemplo a la máquinade Turing.


3 Preliminary Computation Models

The subject of this thesis, which is the search of a suitable computationmodel for algebraic complexity and symbolic computation theory, was initi-ated in [HM93]. First steps towards preliminary versions of such a compu-tation model were given by [GH01], [BGHM01], [CGH+01] and [CGH+03],the generality of the approach applied to constraint data bases may befound in [HK04], our model becomes clear in the context of interpolationin [GHMS11], and a connection with Software Engineering becomes explicitin [RP11] and [HKRP13b]5.

The computation model which appears in [HKRP13b] is now explainedfrom the point of view of software engineering. We are going to constructthat model step by step, and at each step we will add a new software en-gineering notion to produce a computation model more meaningful thanbefore. The result of this gradual process will be a sequence of computa-tion models of increasing expressiveness which describe programs which areincreasingly close to software engineering (see e.g. Figures 20, 26, 27 and30 along this section). This gradual description of our model was inspiredin [Cho10] where Chomsky hierarchy was dened also in a gradual way. Atthe end of this section we ask what are the best possible complexity boundswe can hope for elimination algorithms captured by our preliminary com-putation model. Then we open the door to introduce our new computationmodel in Section 4.

3.1 Elimination in Terms of Abstract Data Types

An elimination algorithm in the sense of this thesis (see Section 2.2 for anintroduction to the elimination problem in the context of eective alge-braic geometry) can be described in terms of inputs and outputs, namely,the input is an existentially quantied formula Φ, and the output is aquantierfree formula Ψ which is logically equivalent to formula Φ. Inorder to illustrate this description consider the following example.

Example 8 (Input and output for a quantier elimination problem).Let X1, . . . , Xn be indeterminates over C and let X := (X1, . . . , Xn). LetM be an n×n matrix. A suitable input for a quantier elimination problemis the quantied formula

Φ := ((∃X)(M ∗X = 0 ∧X 6= 0)). (9)

5Our work [HKRP13b] was honored with the Best Paper Award of the Journal ofComplexity in Montevideo, Uruguay, in the context of FoCM'14 conference. We thankprofessor Ignacio Stolkin for having us in his home with kind hospitality when we at-tended the conference.


Formula Φ describes the existence of a nontrivial solution for a givensystem of linear equations.

Let det(M) be the determinant of matrix M . Observe that formula Φ islogically equivalent to the following quantierfree formula:

Ψ := (det(M) = 0). (10)

Formula Ψ is the corresponding output for a quantier elimination problemon input Φ.

Observe that the main ingredient of formulas Φ and Ψ in (9) and (10)are polynomial equations and inequations. Thus, we may simplify ourdescription of elimination and instead of rst order formulas at the inputand output we may consider only polynomials. Previous works call thepolynomials at the input (M ∗X with X 6= 0 in our previous Example 8)an elimination problem and the corresponding polynomial at the output(det(M) in the same example) an elimination polynomial (see [Gri06] fora description of the determinant as an elimination polynomial). One ofthe most famous elimination polynomials is the PochhammerWilkinsonpolynomial (see equation (7) in Example 7, Section 2.2) whose complexitystatus is still an open question and any light on this subject will be a greatprogress in computer science (see e.g. [HK04] and [Par95]).

Previous observation suggests that an elimination algorithm may bedescribed in terms of a transformation between polynomials instead of rstorder formulas. Thus, we may formulate an elimination algorithm in termsof a function belonging to a given abstract data type of polynomials. Wedescribe with more details this idea in the following paragraph (see Section2.1.1 for an introduction to the notion of abstract data type).

Suppose that we have an abstract data type of polynomials called Poly.We describe Poly by means of the following abstract data type specicationwhich was taken from Liskov's work ([LG00]). For the sake of simplicity, weadapted the abstract data type specication to Meyer's notation ([Mey97])and we omitted details of preconditions and axioms.

• TYPES: Poly

• FUNCTIONS:

poly : →Poly

poly : Integer×Integer→Poly

degree: Poly→Integer

coe : Poly×Integer→Poly

add : Poly×Poly→Poly

mul : Poly×Poly→Poly

minus : Poly×Poly→Poly


• AXIOMS:

A1 the function poly returns the zero polynomial,

A2 given two numbers, say c and d, the function poly ap-plied to c and d returns a monomial with coecient cand degree d,

A3 the function degree returns the degree of a given poly-nomial

A4 given a number e and a polynomial p, the functioncoe returns the coecient of p which corresponds tothe term with exponent e,

A5 the function add returns the sum of two given poly-nomials

A6 the function mul returns the multiplication of twogiven polynomials

A7 the function minus returns the subtraction betweentwo given polynomials

Observe that the previous abstract data type specication correspondsto univariate polynomials under the name Poly. In order to capture elim-ination as a general task we need to consider multivariate polynomials.Thus, let us suppose that we have extended the previous specication toan abstract data type of multivariate polynomials Poly, although we do notexhibit such extension.

Elimination and abstract data type function solve

An elimination problem, as a transformation between polynomials, may bespecied in terms of a (partial) abstract data type function solve of theabstract data type of multivariate polynomials Poly described before. Thearity of this function solve is

solve : Poly × · · · × Poly → Poly . (11)

This arity describes an input composed by a sequence of polynomials (in-stances of the abstract data type Poly) and a single polynomial at theoutput (another instance of Poly called the elimination polynomial).

We may graphically denote abstract data type Poly and its functionsolve with boxes which are a notation frequently used to denote abstractdata types in software engineering bibliography (see e.g. [Mey97], [LG00],[BRJ99] and our example of stacks in Section 2.1.7). Thus, we may denotethe abstract data type with a box labelled Poly and, in order to distinguishthe input from the output, we may add the labels `in' and `out' to obtain


Poly insolve // Polyout

Figure 17: Elimination algorithm as a function solve.

boxes labelled Poly in and Polyout. Then we may graphically denote func-tion solve by means of an arrow connecting these boxes. Figure 17 belowillustrates function solve.

Figure 17 above illustrates the specication of a functionality in termsof abstract data types which is the starting point to implement elimination.The next step is to dene a class whose interface (set of routines or methods)is given by the functions in abstract data type Poly. Thus, we should obtaina software text given by a class which we call class Poly. Among theroutines which compose class Poly we focus our attention on the routinewhich corresponds to function solve, and we call this routine with the samename, although we denote this routine with a dierent font (typewriter)in order to remark that it is software text.

At this point we have two separate worlds which are mutually connected.On one hand, there is an specication given by the abstract data typePoly which gives rise to a software text given by class Poly. In the otherhand, class Poly represents a syntactical programming language, whereasabstract data type Poly (as a mathematical set of polynomials) becomes asemantical mathematical model for class Poly. Figure 18 below illustratesthese two worlds.

Poly

solve()Poly in

solve // Polyout

Figure 18: Class Poly and its mathematical model.

Observe that the right hand side of Figure 18 is a trivial mathematicalmodel for class Poly and routine solve. This model is just a descriptionin terms of elementary set theory (of abstract data types) and does notcapture geometric properties of polynomials and functions between them.These properties will be studied and incorporated in a more precise modelwhich will allow us to obtain complexity lower bounds in the followingsections.


Abstract data type Poly and a more precise mathematical model

Let X1, . . . , Xn, . . . be indeterminates. The abstract data type of multi-variate polynomials Poly is the union of all polynomials, namely

U :=⋃

n∈Z≥0

C[X1, . . . , Xn]. (12)

Set U is a ring which we call an abstract data type carrier of polyno-mials.

Since the arity of function solve in (11) indicates that the input is asequence of polynomials, the input domain of function solve is given byall nite sequences of polynomials described by the following abstract datatype carrier of polynomials where U r is an rtuple:

V :=⋃

r∈Z≥0

U r. (13)

Then, the abstract data type function solve is a partial map τ : V →U between abstract data type carriers of polynomials. Figure 19 belowillustrates this preliminary model where the rst column starting from theleft hand side is the syntactical programming language given by class Poly.The center of the gure is the trivial mathematical model given by abstractdata types. The right hand side of the gure is the semantic mathematicalmodel we have in mind.

Poly

solve()Poly in

solve // Polyout V τ // U

Figure 19: A preliminary model for routine solve.

Observe that in order to give lower complexity bounds we do not needa general model like an abstract data type carrier V at the input, insteadwe may consider only special subsets of V , e.g., in the following we aregoing to choose special subsets which cause complexity blow ups in elimi-nation algorithms. We call a subset O of V framed when the polynomialswe consider are of bounded degree and number of variables. In order tocharacterize this kind of subsets we need the following denition.

Denition 9 (constructible subset). Let X1, . . . , Xn be indeterminatesover C and let X := (X1, . . . , Xn). Let C[X] := C[X1, . . . , Xn] be thering of polynomials in the variables X with coecients in C. LetM be asubset of the ane space Cn. We call the subsetM constructible ifM isdenable by a Boolean combination of polynomial equations from C[X].


All abstract data type carriers we are going to consider in this thesis canbe covered by constructible subsets of nite dimensional vector subspacesof V . A framed abstract data type carrier is such a constructible set.

In order to illustrate the notion of framed abstract data type carrierconsider the following example.

Example 10 (Framed abstract data type carrier). Let us x a discreteparameter D := 2r+1 − 1 for some r ≥ 0. Let T be a parameter variable ofC and let X be an indeterminate of C. Let us x an univariate polynomial

P (X) := (TD − 1)∑

0≤k≤D

T kXk.

If we specialize the parameter variable T in values t ∈ C, we obtain in-stances of the polynomial P , e.g.,

with t := 0 we obtain the polynomial (0D − 1)∑

0≤k≤D 0kXk which isthe zero polynomial,

with t := 1 we obtain (1D − 1)∑

0≤k≤D 1kXk which is the zero poly-nomial again,

with t := 2 we obtain (2D − 1)∑

0≤k≤D 2kXk which is a nonzeropolynomial, etc.

In particular, we obtain the following framed abstract data type carrier:

OD := (tD − 1)∑

0≤k≤D

tkXk : t ∈ C. (14)

In order to stress that the polynomials in OD are polynomials of boundeddegree D, we subscript O with D in (14). For the sake of simplicity, we omitin the following the subscript D which will appear only when we considerspecic examples.

In our notations we shall not further insist on the dierence of framedabstract data type carriers and unframed ones. We return now to thegeneral model in previous Figure 19 where function solve is a mathematicalmodel for routine solve, and we introduced a more precise model namelythe partial map τ : V → U .

Observe that in the examples we described before the function solvealways produces a single output polynomial (an elimination polynomial).Thus, we should model the output domain with a framed abstract datatype carrier O′ contained in U . To illustrate the notion of framed abstractdata type carrier O′ at the output consider the following example.


Example 11 (Framed abstract data type carrier at the output). Let ODbe the framed abstract data type carrier in equation (14). Let τD be thederivative with respect of the variable X. If we apply τD to the polynomial

P (X) := (TD − 1)∑

0≤k≤D

T kXk

of the previous example, we obtain its derivative which is the polynomial

P ′(X) = τD(P ) = (TD − 1)∑

1≤k≤D

kT kXk−1.

Observe that we may specialize parameter variable T of polynomial P ′ inseveral values as before. We obtain the following framed abstract data typecarrier:

O′D := (tD − 1)∑

1≤k≤D

ktkXk−1, t ∈ C. (15)

In this way, we are going to replace function solve with a map τ betweenframed abstract data type carriers O and O′. In order to remain in thelanguage of polynomial equations and avoid the modelling of other kind ofapplications, we require that the map τ is constructible.

Denition 12 (constructible map). A map Φ : Cn → Cm is a constructiblemap if the graph of Φ is denable by a Boolean combination of polynomialequations from C[X].

Observe that previous Denition 12 refers to constructible maps be-tween ane spaces Cn and Cm. This denition of a constructible map isalso applicable to maps between framed abstract data type carriers. Thus,our model for routine solve given by the abstract data type function solvebecomes a more precise model given by the constructible map τ : O → O′between framed abstract data type carriers of polynomials O and O′. Fig-ure 20 below illustrates this description.

Poly

solve()Poly in

solve // Polyout O τ // O′

Figure 20: A more suitable model for routine solve.

Observe that this part of the thesis, where we replaced a general modellike the abstract data type Poly and the abstract data type carrier V by amore precise notion like a framed abstract data type carrier O ⊂ V , is aclear example of tuning the model which we mentioned at the introduction.


3.2 CircuitBased Elimination Algorithms

Now we are going to study the following software design behind circuitbased elimination algorithms.

Poly

Slp

Figure 21: Basic design behind elimination algorithms.

Suppose that our class Poly has arithmetic circuits in the role of choiceof representation (see Section 2.1.2 for an introduction to this notion).Suppose also that our arithmetic circuits are divisionfree, i.e., the divisionoperation is not allowed on the nodes, otherwise a circuit could representa more general kind of functions called rational functions instead of justpolynomials. Thus, there exists a class Slp (slp is the acronym of straightline program) which implements the data structure of arithmetic circuitsand this class Slp composes the private part of Poly. This connectionbetween polynomials and arithmetic circuits is the basic design behindcircuit-based elimination algorithms. Figure 21 above illustrates the classdiagram for this basic design.

Now we introduce a mathematical connection between arithmetic cir-cuits and polynomials which is given by the notion of abstraction function.Since classes Poly and Slp are software text, we are going to give a math-ematical model for this software text. A preliminary model should be anabstract data type of multivariate polynomials Poly and an abstract datatype of arithmetic circuits Slp, both of them connected by means of an ab-straction function which sends circuits into polynomials. As we explainedin the previous section, we may graphically denote the abstract data typeof polynomials with a box labelled Poly and the arithmetic circuits im-plementing this abstract data type with a box labelled Slp. Thus, ourabstraction function, we call abs, may be visualized as an arrow connectingthese boxes. Figure 22 below illustrates this description which is a pre-liminary model for class diagram in Figure 21. This connection between amathematical model and a software design opens the door to an applica-tion of our model in the early step of design in the software constructionprocess (see Section 5.3.2 for a detailed description of this application).

We suppose that class Poly implements elimination by means of a rou-tine called solve which is the software text implementing our function solve


Poly

Slp

Poly

Slp

abs

OO

Figure 22: Choice of representation Slp and abstract data type Poly.

in abstract data type Poly. Thus, we introduce now the implementation ofroutine solve in terms of arithmetic circuits. Since our current design andour model of abstract data types in Figure 22 above indicates that polyno-mials are implemented by means of divisionfree arithmetic circuits (choiceof representation Slp), any routine of the class Poly should be implementedin terms of arithmetic circuits including routine solve. Thus, an imple-mentation of routine solve (the software text dening its body) should bemodelled by a map between arithmetic circuits we call csolve, the prex cindicates that this map is the concrete version (or the implementation) ofthe abstract data type function solve. If we call Slp in and Slpout the inputand output of map csolve, then, if the implementation csolve is correctwith respect to its specication solve by means of an abstraction functionabs, we obtain the following commutative diagram in Figure 23 below inthe style of [Mey97] (compare with Figure 8).

Poly

solve()

Slp

Poly insolve // Polyout

Slp in

abs

OO

csolve // Slpout

abs

OO

Figure 23: Routine solve and its mathematical model.

Figure 23 illustrates the standard structure that any implementation ofabstract data type functions should follow ([Hoa72], [Mey97], [LG00]), inparticular, Figure 23 above is the basic structure inside circuitbased elimi-nation algorithms. Of course, there is an alternative structure to implementan elimination algorithm. This alternative is the objectoriented approachwhich we introduce to our model in Section 4. Let us now conclude ourmathematical model for the standard structure in Figure 23.


A suitable mathematical model for arithmetic circuits

In this section we are going to introduce a suitable mathematical modelfor arithmetic circuits. A well known model for arithmetic circuits is themodel of directed acyclic graphs (see Section 2.2.2 for an introduction tothis data structure). In this work we describe arithmetic circuits in analternative and dierent form.

Recall from Figure 20 that a model for class Poly and routine solve

is the abstract data type of multivariate polynomials denoted as Poly inand Polyout and we replaced this model with the more precise notion offramed abstract data type carriers O and O′ respectively. Observe thateach polynomial in a framed abstract data type carrier is evaluable by anarithmetic circuit of xed size (see e.g. framed abstract data type carrierOD in Example 13 below). Thus, we may suppose that O and O′ areevaluated by arithmetic circuits β and γ of xed size l and m respectively.Recall from Figure 23 that our preliminary model for the body of routinesolve is the map csolve between arithmetic circuits. We may replace thisgeneral model with a map ϕ between arithmetic circuits of xed size β andγ which is a more precise model. Figure 24 below illustrates this idea.

Poly insolve // Polyout O τ // O′

Slp in

abs

OO

csolve // Slpout

abs

OO

βϕ

//

OO

γ

OO

Figure 24: Map csolve in terms of arithmetic circuits β and γ.

Observe that the arithmetic circuit β (as well as γ) is a labelled directedacyclic graph which may be described by the following standard notation

β := (V,E) (16)

where V is the set of nodes of the graph and E is the set of directed edgesconnecting the nodes (see e.g. [GY05]).

In order to give lower complexity bounds we do not need to capturethe internal structure of the arithmetic circuit β given by the pair (V,E).Instead, we only consider the set of nodes V which we interpret as a setof parameters needed to create circuit β. We model this set of parameterswith a constructible subset of an ane ambient space over C. We call thissubset a framed data structure N .


The size of a framed data structure N is the dimension of its ambientspace. The following example illustrates the notion of framed data structureand its size.

Example 13 (Framed data structure). Let us consider the framed abstractdata type carrier OD in Example 10, namely

OD := (tD − 1)∑

0≤k≤D

tkXk : t ∈ C.

Let T be an indeterminate and D := 2r+1− 1 for some r ≥ 0. The polyno-mial

(TD − 1)∑

0≤k≤D

T kXk

is a polynomial which is easy to evaluate, i.e., we need O(log(D)) nodesto create an arithmetic circuit evaluating polynomials in OD (see AppendixC for a proof of this bound). Thus, we require a framed data structureND of size O(log(D)) to capture the necessary parameters to create suchcircuit. Notice that if the data structure implementing polynomials is givenin terms of coecients or dense representation we need a dierent frameddata structure N ′D of size O(D). Figure below illustrates this dierence.

OD OD

aaaaaaaND ⊂ ClogD

OO

aaaaaaN ′D ⊂ CD

OO

Figure 25: Two dierent framed data structures for OD.

Observe that Figure 25 indicates that between the framed abstract datatype carrier OD and its framed data structure ND there exists a mapping(an arrow) which has not been detailed yet. This mapping is given by theunderlying arithmetic circuit as we describe in the following paragraph.

We return now to the mathematical model in previous Figure 24. Weare going to give a more precise mathematical counterpart of abstractionfunction abs :Slp in →Poly in.

At this point, we have a framed abstract data type carrier O and aframed data structure N where each instance parameter in N representsan instance polynomial in O. Observe that the mapping of a given instancein N to the corresponding polynomial in O is given by the underlyingarithmetic circuit, namely, the circuit denes the connection between nodesto represent a polynomial in O. Thus our mapping between N and O is


a map ω : N → O which is dened by the internal arithmetic operationsof circuit β. Since our circuits are divisionfree, the map ω is a polynomialmap according to the following denition.

Denition 14 (polynomial map). Let V and W be closed ane subvari-eties of Cn and Cm respectively. Let φ : V → W be a partial map andlet φ1, . . . , φm be the components of φ. The map φ is called a morphismof ane varieties or just polynomial map if the complex valued functionsφ1, . . . , φm belong to C[V ]. Thus, in particular, φ is a total map (see Ap-pendix C).

Thus, we replace abstraction function abs :Slp in →Poly in in Figure 24above with the more precise notion of a polynomial map ω : N → Obetween a framed data structure N and a framed abstract data type carrierO.

Observe that the polynomial map ω is a model like abstraction func-tion abs (at the input). Similarly, we may describe a model at the output.Recall from Figure 24 that the framed abstract data type carrier O′ at theoutput may be implemented by an arithmetic circuit γ of size m. Thus O′requires a framed data structure N ′ of size m. The connection between agiven parameter in N ′ and the corresponding polynomial in O′ is a poly-nomial map ω′ : N ′ → O′. Thus, we may replace abstraction functionabs :Slpout →Polyout with the more precise notion of a polynomial mapω′ : N ′ → O′.

Finally, our preliminary map ϕ : β → γ between arithmetic circuits βand γ introduced in Figure 24 above becomes a constructible map ϕ : N →N ′ between framed data structures N and N ′ which is a more suitablemodel than map csolve. Figure 26 below illustrates our model.

Poly insolve // Polyout O τ // O′

Slp in

abs

OO

csolve // Slpout

abs

OO

N ϕ//

ω

OO

N ′

ω′

OO

Figure 26: Abstraction functions ω and ω′.

At this point we have a preliminary model (still incomplete) for circuitbased elimination algorithms. In order to improve this preliminary modelwe are going to specify some points we should take into account.


Observation 15. Let the size of Slpout be the number of internal nodesfor an arithmetic circuit belonging to Slpout. Observe that the dimension ofthe framed data structure N ′ becomes a lower bound for the size of Slpout.This value represents our complexity measure.

Observation 16. Our model in Figure 26 is still incomplete in terms ofnonfunctional requirements which we introduce in the next section.

About abstraction levels

Observe that our elimination algorithms are implemented at the level ofarithmetic circuits. We ask now what happens if we work at a level whichmay be lower than arithmetic circuits. First of all, a software engineeringcan rene its program at arbitrary levels of abstraction, however few pro-grammers work at bit level. In addition, according to Brooks, the author ofNo Silver BulletEssence and Accidents of Software Engineering, softwareimprovement should be carried out at a high level of abstraction ([Bro87]).Thus, arithmetic circuits appear to be a reasonable level of abstraction towork.

3.3 Robust Elimination Algorithms

In this section we consider a nonfunctional property that function solveof our previous model in Figure 26 should satisfy. We are interested infunctions which are robust in the sense of [Mey97], i.e., robustness as theability of software systems to react appropriately to cases not covered by thespecication. Thus, we should describe which are those cases not coveredby the specication and which is an appropriate reaction of the system inthe case of elimination algorithms.

Observe that although the non-functional requirement of robustness is akey software quality attribute in software development ([BCK98]), robust-ness is not only restricted to large software systems. Indeed, robustness isalso an advantageous property of algorithms in polynomial equation solving(see e.g. [Pan97]).

Robustness is a non-functional requirement for function solve

An abstract data type specication constitutes a description of functionalrequirements where nonfunctional requirements such as robustness be-come excluded (see Section 2.1.5 for an introduction to the notion of ro-bustness). Thus, we should add robustness to our abstract data type Polyas an additional requirement. The problem of this operation is that weare not able to describe precisely a robustness requirement at the level ofabstract data type specications. However, our mathematical model allows


us to describe precisely a special case of robustness in the context of elimi-nation algorithms. In the case of functions applied to polynomials there isa continuity property which should be satised. Thus, we may argue thata continuity requirement is a special case of robustness and would serve asa suitable model for the notion of robustness applied to the case of elimi-nation algorithms (see [CGL12] for another example where continuity is aspecial case of robustness).

Geometrical robustness is our model for robustness

At this point we require that routine solve in class Poly satises the nonfunctional requirement of robustness. Thus, we also require that functionsolve satises this nonfunctional requirement. We model this requirementwith the mathematical property of continuity as a special case of robust-ness. The notion of a continuous function becomes precisely described bythe notion of a geometrically robust map.

Denition 17 (Geometrically robust map). Let M be a constructiblesubset of Cn and let Φ : M → Cm be a constructible total map. ThenΦ is geometrically robust if Φ is continuous with respect to the Euclideantopologies ofM and Cn (see [HKRP13b, Theorem 4]).

In the model of abstract data types we may require that function solveis robust, but in our model we require that the map τ : O → O′ is geomet-rically robust (or equivalently we require that the map τ is continuous).Figure 27 below illustrates this new element in our model.

Poly in

robustness︷︸︸︷solve // Polyout O

geometrical robustness / continuity︷︸︸︷τ // O′

Slp in

abs

OO

csolve // Slpout

abs

OO

N ϕ//

ω

OO

N ′

ω′

OO

Figure 27: Software engineering robustness and geometrical robustness.

Observe that the map ω is a polynomial map, then by Theorem 38(iv) in Appendix B.2 the map ω is also geometrically robust. This impliesthat the composition ω τ is geometrically robust. Thus, the compositionω′ϕ should be also geometrically robust. Since the map ω′ is a polynomialmap and therefore geometrically robust, we also require that the map ϕ isgeometrically robust.


Branching Parsimoniousness

It is important to mention that the tactics used to implement the nonfunctional requirement of robustness (see e.g. [BCK98]) may be representedin our case of elimination algorithms by the notion of branching parsimo-niousness which is an important characteristic of circuitbased eliminationalgorithms. Observe that csolve has to implement function solve includ-ing its nonfunctional requirement of robustness. An easy approach tosatisfy robustness is to avoid divisions in the elimination algorithm. How-ever, avoiding divisions of any kind is unnecessarily restrictive, thus certaindivisions which can be replaced by limit processes are admitted. In this sce-nario, the notion of branching parsimoniousness appears when the specialdivisions described before are implemented by if statements (branchings)which are controlled and free of divisions by zero (parsimoniousness).

Geometrically Robust Abstraction Function

We are going now to introduce the notion of geometrically robust abstrac-tion function to generalize our previous model in Figure 27 above. Recallour example of framed abstract data type carriers given by (14) and (15)where we described that each polynomial in a framed abstract data typecarrier O has the same formula which is specialized by a parameter t. Re-call also that our model for the representation of polynomials is given bythe set of parameters N used to construct a suitable arithmetic circuitevaluating the polynomials in O. Notice that the parameter t does notbelong to the set of parameters N , parameter t is a dierent parameterwhich determines polynomials in O. Since our framed abstract data typecarriers of polynomials are determined by a single parameter t, we mayreparametrize the set N by the set of parameters which determines thepolynomials in O in the sense of parameter t (see [HK04] for a comparisonbetween parameters and variables). If we model the set of parameters twith a new framed data structure calledM, the reparametrization of Nmay be given by a map µ which sends M into N . The result of this reparametrization is a map θ which sends M, the set of parameters t, intoO. Figure 28 below illustrates this idea.

In order to understand the dierence between parameters in M andparameters in N recall Example 13 above where a framed abstract datatype carrier OD admits two dierent framed data structures, namely ND ⊂ClogD and N ′D ⊂ CD. However, OD can be reparametrized byM := C.

An important property of reparametrization µ is that it should be ageometrically robust map. We may justify this requirement if we interpretthe map µ as an algorithm which transforms a parameter t into a set ofparameters necessary to dene an arithmetic circuit. Since our algorithmsshould be robust, the map µ should be geometrically robust. The conse-


O

Nω

OO

M

µ

OOθ

FF

Figure 28: Reparametrization of framed data structure N .

quence of this requirement is that the new map θ is a geometrically robustmap. Since θ is an abstraction function, θ becomes a geometrically robustabstraction function.

The same operation described before may be carried out to reparametrizethe setN ′ at the output. Figure 29 below illustrates this reparametrization.

O τ // O′

N ϕ//

ω

OO

N ′

ω′

OO

M

µ

OO

θ

II

µ′

CC

θ′

UU

Figure 29: Geometrically robust abstraction functions θ and θ′.

In order to simplify our model, notice that the map ϕ between N andN ′ may be omitted if we consider the reparametrization maps µ and µ′.Thus, our model becomes simplied and we obtain the diagram in Figure30 below.

Observation 18. Observe that our model described by the right hand sideof Figure 30 does not follow the standard denition of model, namely, amodel as an abstraction and a representation of a complex reality. Indeed,our model is a particular and precisely described case of the general com-puter science scenario described by the left hand side of the gure.

Lower complexity bounds

Figure 30 illustrates a model for circuit-based elimination algorithms. Inthis context, a suitable complexity measure to obtain lower complexity


Poly in

robustness︷︸︸︷solve // Polyout O

geometrical robustness︷︸︸︷τ // O′

Slp in

abs

OO

csolve // Slpout

abs

OO

N

ω

OO

N ′

ω′

OO

M

µ

OO

θ

II

µ′

DD

θ′

VV

Figure 30: Parameterized model for robust circuitbased elimination.

bounds is the size of the output of our elimination algorithms. This out-put is an arithmetic circuit whose mathematical model is the framed datastructure N ′. The main result in [HKRP13b] is an exponential lower boundfor the size of N ′. Thus, according to [HKRP13b] circuit-based and geo-metrically robust elimination algorithms are intrinsically hard.

In the following section our model for circuitbased elimination algo-rithms is generalized in order to describe elimination algorithms which donot depend on the implementation of polynomials.


Modelos de Cómputo Previos

El tema de esta tesis es la búsqueda de un modelo de cómputo adecuadopara el estudio de complejidad algebraica en computación simbólica, estabúsqueda se inició en el trabajo [HM93]. Los primeros pasos hacia ver-siones preliminares del modelo de cómputo que vamos a estudiar en estasección fueron dados por [GH01], [BGHM01], [CGH+01] y [CGH+03], lageneralidad del enfoque se aplicó a las bases de datos continuas en [HK04].Finalmente nuestro modelo se vuelve claro en el contexto de interpolaciónen [GHMS11], y una conexión con Ingeniería de Software se vuelve explícitaen [RP11] y [HKRP13b].

El modelo de cómputo que aparece en [HKRP13b] se explica ahoradesde el punto de vista de la Ingeniería de Software. Vamos a construirese modelo paso a paso, y en cada paso vamos a introducir un nuevo con-cepto de Ingeniería de Software para obtener un modelo de cómputo másexpresivo que el anterior. El resultado de este proceso gradual será unasecuencia de modelos de cómputo de expresividad creciente que describenprogramas cada vez más parecidos a programas producidos mediante téc-nicas y nociones básicas y fundamentales de la Ingeniería de Software (verFiguras 20, 26, 27 y 30). Esta descripción gradual de nuestro modelo seinspiró en [Cho10], donde la jerarquía de Chomsky se denió también demanera gradual. Al nal de esta sección nos preguntamos cuáles son lasmejores cotas inferiores de complejidad posibles que podemos esperar paralos algoritmos de eliminación capturados por nuestro modelo de cómputopreliminar. Esta pregunta nos abre la puerta para presentar nuestro nuevomodelo de cómputo y el resultado principal de esta tesis en la siguienteparte (ver Sección 4).


4 Quiz Games Computation Model

Dedicated to professor Joos et les mousquetaires

At this point we have formulated elimination algorithms by means of aroutine called solve which belongs to class Poly. Observe that a routineand a class are software text which admit a semantic mathematical modelin terms of abstract data types. A function called solve belongs to the ab-stract data type of multivariate polynomials Poly, and it is implemented interms of arithmetic circuits by means of the map csolve which representsa robust circuitbased elimination algorithm. We consider now the casewhere arithmetic circuits are replaced with another data structure. In thiscase, routine solve would become useless because a new data structurewith a possible incompatible interface has replaced arithmetic circuits. Astrategy to avoid this situation is to use objectoriented algorithms wherethe representation of polynomials remains hidden, i.e., we have freedom tochose the data structures which represent the polynomials without modify-ing the algorithm. To be precise, routine solve should be dened in termsof other routines of the class Poly like our objectoriented implementationof routine size of stacks in Example 5, Section 2.1.7. Thus, from Remark6, and in the context of a mathematical model of abstract data types, func-tion solve should be dened in terms of other functions namely creators,commands and queries (constructors and observers). At the end of thissection we ask what are the best possible complexity bounds we can hopefor this kind of elimination algorithms.

4.1 ObjectOriented Elimination

In this section we are going to work with the model of abstract data typesdescribed before and we will forget for a while the class diagram whichoriginated this model.

The functions in the abstract data type Poly constitute an interfacewhich is the tool available for the programmer to dene an objectorientedalgorithm which operates with polynomials (see e.g. [Mey97] and [GHJV95]).Thus, there exists an objectoriented version of function solve which, with-out loses of generality, has the following form. As a rst step, queries(observers) are applied to the input. These queries (observers) return val-ues which may be used to compute the output by means of creators andcommands (constructors). In order to distinguish between the output offunction solve, namely Polyout, and the output of its objectoriented ver-sion, we denote the output of our objectoriented algorithm with a boxlabelled Poly∗out as Figure 31 below illustrates.


Poly∗out constructorsoo Poly inobservers

oo

object-oriented algorithm

vv

solve // Polyout

Rep∗out

abs∗

OO

Slp in

abs

OO

csolve // Slpout

abs

OO

Figure 31: Function solve as an objectoriented algorithm.

Notice that the box labelled Poly∗out denotes an abstract data type ofmultivariate polynomials where each polynomial is a semantic concept, ifwe want to describe the space which this polynomial occupies in the mem-ory of a computer we have to x a representation (recall that our complexitymeasure is the size of the output). We denote this representation as Rep∗out(Rep is the acronym of representation). Then, a suitable combination ofqueries, creators and commands (observers and constructors) produces anobjectoriented elimination algorithm where the representation of polyno-mials does not have a special role. Indeed, Rep∗out may be a dierent datastructure and the connection between Rep∗out and Poly∗out may be given byan abstraction function abs∗ :Rep∗out →Poly∗out.

Since Slpout and Rep∗out may be dierent data structures, we deducethat any change in the representation of polynomials becomes invisible tothe objectoriented algorithm. In order to illustrate this notion of invisiblechange of the representation consider the example of Appendix A wherewe show an implementation of the identity function which changes therepresentation of a given class without direct access to this representation.

Observe that our objectoriented algorithm in Figure 31 is decomposedin two parts: one application of queries (observers) followed by one appli-cation of creators and commands (constructors). This structure is a sim-plication in order to obtain a simple description. Observe that an objectoriented algorithm may apply queries, creators and commands (observersand constructors) in arbitrary order and quantity. This characteristic ofobjectoriented algorithms becomes captured by our Quiz Game protocolin the following section.


4.2 Quiz Game: a Model for Information Hiding

At this point of the thesis we have described two approaches to eliminationalgorithms. The rst approach (which was described in Section 3) is thestandard one and consists of elimination as a function solve of the abstractdata type of multivariate polynomials Poly which is implemented in termsof a xed data structure Slp which is given by arithmetic circuits. Thesecond approach suggests that we can implement function solve in terms ofother abstract data type functions, namely queries, creators and commands(observers and constructors). This approach produces an objectorientedalgorithm with the benet of information hiding (see Section 2.1.6 for anintroduction to this concept). Now, we are going to give a suitable mathe-matical model for this second approach.

First of all, we model the output of queries (observers) with a frameddata structureM∗, which will also model the input of constructors. Then,our model for queries (observers) becomes a map σ : O → M∗. On theother hand, we model the abstract data type output Poly∗out with a framedabstract data type carrier of polynomials O∗. Then, our model for creatorsand commands (constructors) becomes a map θ∗ : M∗ → O∗. In thesame vein, we model Rep∗out with a framed data structure N ∗ and theabstraction function abs∗ with a map ω∗ : N ∗ → O∗. To capture the natureof N ∗ as a computational result, we introduce the map µ : M∗ → N ∗to model the implementation of (constructor) θ∗. Then, the compositionθ∗ σ becomes our mathematical model for an objectoriented eliminationalgorithm which implements function solve. Figure 32 below illustrates ourmathematical model, the composition θ∗ σ is highlighted by bold arrows6.

O∗ M∗ooooθ∗oo

µ∗

O τ //ooooσoo O′

N ∗

ω∗

OO

N

ω

OO

N ′

ω′

OO

M

µ

OO

θ

II

µ′

CC

θ′

UU

Figure 32: Mathematical model for objectoriented elimination.

Notice that although the map θ∗ models a creator or command (con-structor), this map also admits an interpretation as an abstraction function.

6We thank Alejandro Prieto for fruitful discussions which suggested the interpretationof the composition θ∗ σ in terms of an objectoriented algorithm.


Suppose thatM∗ is the set of parameters to dene polynomials in O∗ in-stead of the output of query (observer) σ. Thus, we may interpret M∗

as a reparametrization of N ∗ (the set of parameters to dene a circuitevaluating a polynomial in O∗). In this sense the map θ∗ appears to be ageometrically robust abstraction function.

It is not the rst time a same mathematical object has two dierentnames from two dierent points of view, e.g., consider the case of thecreators (constructors) for stacks. A standard creator for stacks receivesa vector of integers as parameter and produces an instance of stack withthose integers as elements of the stack. The arity of such a creator functionaccording to Example 1 of stacks may be:

new:[INTEGER]→ STACK[G] (17)

Let us consider now the denition of abstraction function and supposethat the representation of stacks is given by a vector of integers [INTE-GER], in this sense the creator function (constructor) new of (17) has thesame arity of an abstraction function.

Our interpretation of map θ∗ as an abstraction function introduces anew abstraction function to the model. In order to compare two dierentabstraction functions we introduce the notion of compatible collection ofabstraction functions.

Compatible collections of abstraction functions

Let be given two framed abstract data type carriers O1 and O2, twoframed data structures N1 and N2 and two surjective polynomial mapsω1 : N1 → O1 and ω2 : N2 → O2. Then the number of variables and thedegrees of the polynomials occurring in O1 and O2 are bounded. There-fore we may assume without loss of generality that the elements of O1

and O2 are polynomials of C[X1, . . . , Xn] of degree bounded by a xed in-teger parameter ∆ ≥ 2. Let L be the size of the framed data structureN1×N2 and suppose that there exists a quantierfree rstorder formulaover C which denes N1 × N2 involving K polynomial equations of de-gree at most ∆ in L variables. Without loss of generality we may assumeK ≤ ∆L. Finally we assume that the degree of the polynomials deningω1 × ω2 : N1 ×N2 → O1 ×O2 is bounded by ∆.

For m ∈ N, we call (γ1, . . . , γm) ∈ Cn×m an identication sequence forO1×O2 if the equalities f(γ1) = g(γ1), . . . , f(γm) = g(γm) imply f = g forany f ∈ O1, g ∈ O2.

The next statement guarantees that there exist forO1×O2 many integeridentication sequences of small length m := 4L + 2 and of small bit sizeO(L log ∆) which may be chosen randomly. For the proof of this result,we refer to [CGH+03, Lemma 4 and Corollary 1].


Proposition 19. Let notations and assumptions be as before. Let ∆ ≥ 2 bean integer parameter. Let L be the size of the framed data structure N1×N2.Let K ≤ ∆L be the number of polynomial equations of degree at most ∆ inL variables dening N1×N2. Let M be a nite subset of C1. Suppose thatthe cardinality #M of M satises the estimate #M ≥ ∆3(1+L)

1L (1+K∆)

and let be given an integer m ≥ 4L+ 2. Then there exist points γ1, . . . , γmof Mn such that (γ1, . . . , γm) forms an identication sequence for O1×O2.

Suppose that the points of the nite set Mn are equidistributed. Thenthe probability of nding by a random choice in Mn×m an identicationsequence is at least 1− 1

#M≥ 1

2.

Suppose that for any (v1, v2) ∈ N1 ×N2 and any ξ ∈ Cn we are able toevaluate ω1(v1)(ξ) and ω2(v2)(ξ) eciently, i.e., using a number of arith-metic operations in C which is polynomial in L (this occurs when familiesof polynomials are represented by robust arithmetic circuits). Then wemay set up an algebraic computation tree of size polynomial in L which forany pair (v1, v2) ∈ N1 ×N2 decides whether ω1(v1) = ω2(v2) holds.

We are now going to axiomatize this situation as follows. Let I bean index set and H := (θi, µi, ωi)i∈I be a collection of abstraction func-tions θi :Mi → Oi associated with geometrically robust constructible andpolynomial maps µi : Mi → Ni and ωi : Ni → Oi, respectively. Wecall the collection H compatible if for any i, j ∈ I there is given an alge-braic computation tree of depth polynomial in the sizes of θi and θj (themaximum between the size ofMi and Ni, and the maximum between thesize ofMj and Nj) which for any pair (vi, vj) ∈ Ni ×Nj decides whetherωi(vi) = ωj(vj) holds.

Oi × Oj

Ni

OO

× Nj

OO

Mi

OOθi

HH

× Mj

OOθj

VV

Figure 33: A pair of abstraction functions θi and θj .

Quiz Game protocol

Recall that an objectoriented algorithm may apply queries, creators andcommands (observers and constructors) in arbitrary order and quantity.


This characteristic represents the creativity of an objectoriented program-mer. We capture this creativity with a game where there is a player whichmodels the programmer and a quizmaster which models the objectorientedparadigm where the programmer works. The player (programmer) has un-limited computational power (we do not restrict his creativity) but he isonly restricted to use functions provided by the abstract data type of mul-tivariate polynomials Poly, namely queries, creators and commands (ob-servers and constructors). This restriction on the functions available to theplayer in combination with its unlimited power to combine such functionsmodels an objectoriented algorithm.

On the other hand, the quizmaster, who models the computation prob-lem to solve, hides the internal representation of polynomials and onlyprovides queries, creators and commands (observers and constructors) towork with polynomials. Direct access to the representation is denied andthe player does not know whether the polynomials are given by coe-cients, arithmetic circuits, or other data structure. Thus, the quizmasteralso models the notion of information hiding.

The following points describe the protocol for an instance of the game.

• In a rst step, the quizmaster chooses a parameter u inM which bymeans of the abstraction function θ represents an input polynomial ofthe framed abstract data type carrier O, namely θ(u). Thus, param-eter u is also a representation of polynomial θ(u). This polynomialθ(u) determines an output polynomial τ(θ(u)) which is the result ofthe elimination task τ . The player is required to compute this outputpolynomial by means of operations applied to the polynomial θ(u).The quizmaster hides the representation u and only provides queries,creators and commands (observers and constructors) to operate withpolynomial θ(u).

• In a second step, the player asks the quizmaster questions about theinput polynomial θ(u). These questions are limited to query functions(observers). Consequently, quizmaster's answers σ(θ(u)) constitute avector of Cvalues which depend only on the input polynomial θ(u)and are independent of the hidden representation u.

• In a third step, the player applies creators and commands (construc-tors) to quizmaster's answers σ(θ(u)) to compute the required outputpolynomial τ(θ(u)).

• Finally, the player sends to the quizmaster his computation µ∗(σ(θ(u)))which is a representation for the output polynomial. Then, the quiz-master tests whether player's representation v∗ := µ∗(σ(θ(u))) repre-sents the required output polynomial τ(θ(u)). To this end, the quiz-master checks whether ω∗(v∗) = τ(θ(u)), in such a case the player


wins the instance of the game given by u. Observe that this last testis carriedout by the quizmaster within ecient complexity boundssince θ′ and θ∗ belong to a compatible collection of abstraction func-tions. Thus, this step has no inuence in the complexity of the wholeprocess.

Denition 20 (Size of an abstraction function). Let O be a framed ab-stract data type carrier of polynomials,M and N framed data structures,µ : M → N a geometrically robust constructible map and ω : N → Oa polynomial map such that the abstraction function θ := ω µ sendsMonto O. The maximal size ofM and N is called the size of θ.

We say that the player has a winning strategy if he wins the game forany u ∈M. Observe that σ and θ∗ = ω∗ µ∗ dene a winning strategy forthe quiz game protocol if and only if

θ′ = ω∗ µ∗ σ θ

holds. In this case we have O′ = O∗. In other words, a winning strategyfor the quiz game protocol says that the composition θ∗ σ is a correctimplementation for the computation task τ : O → O′.

We say that the computation task determined by τ is feasible if the sizeof θ′ is polynomial in the size of θ. A winning strategy is called ecientif the size of θ∗ is polynomial in the size of θ (and therefore polynomialin the size of θ′ for a feasible computational task). Otherwise it is calledinecient.

Lower complexity bounds

The idea behind our Quiz Game protocol is the following. It is supposedthat σ(θ(u)) and v∗ are complex vectors of short length, whereas explicitdescriptions of the framed abstract data type carrier O∗ may become huge.To be precise, our model allows us to give an exponential lower bound forthe dimension of N ∗. This result is our main theorem in Section 5.2 (seeTheorem 25).


Modelo de Cómputo Quiz Games

En la sección anterior hemos formulado los algoritmos de eliminación pormedio de una rutina (método de clase) llamada solve que pertenece a laclase Poly, una implementación de la noción de tipo abstracto de datosde polinomios multivariados que hemos llamado Poly. En esta sección re-marcamos el hecho de que una rutina y una clase son textos de softwareque admiten un modelo matemático semántico en términos de tipos ab-stractos de datos. Un problema de eliminación se puede especicar conuna función llamada solve perteneciente al tipo abstracto de datos parapolinomios multivariados Poly, y se implementa en términos de circuitosaritméticos. El resultado es una función que podríamos llamar csolve yrepresenta un algoritmo de eliminación basado en circuitos aritméticos queademás cumple con el requerimiento nofuncional de robustez.

Consideramos ahora el caso en el que los circuitos aritméticos son reem-plazados por una estructura de datos diferente. En este caso, la rutinasolve se volvería inútil porque una nueva estructura de datos con unaposible interfaz incompatible ha reemplazado los circuitos aritméticos. Unaestrategia para evitar esta situación es utilizar algoritmos orientados a ob-jetos donde la representación de polinomios permanece oculta, i.e., tenemoslibertad para elegir las estructuras de datos que representan los polinomiossin modicar el algoritmo de eliminación. Para ser exactos, la rutina solvedebería denirse en términos de otras rutinas de la clase Poly como nues-tra implementación orientada a objetos de la rutina size de stacks en elEjemplo 5 de la Sección 2.1.7. En el contexto de un modelo matemáticode tipos abstractos de datos, la función solve debería denirse en términosde otras funciones, i.e., creadores, comandos y consultas (constructores yobservadores), como indica la siguiente gura:

Poly∗out constructoresoo Poly inobservadores

oo

algoritmo orientado a objetos

vv

solve // Polyout

Rep∗out

abs∗

OO

Slp in

abs

OO

csolve // Slpout

abs

OO

Figure 34: Función solve como un algoritmo orientado a objetos.

Por lo tanto un algoritmo de eliminación orientado a objetos puede


aplicar consultas, creadores y comandos (observadores y constructores) enorden y cantidad arbitraria. Esta libertad representa la creatividad deun programador en el paradigma orientado a objetos. Capturamos estacreatividad con un juego llamado Quiz Game donde hay un player quemodela el programador y un quizmaster que modela el paradigma orientadoa objetos donde el programador trabaja. El player (programador) tienepoder computacional ilimitado (no limitamos su creatividad), pero sóloestá restringido a utilizar funciones proporcionadas por el tipo abstractode datos de polinomios multivariados Poly, a saber, consultas, creadores ycomandos (observadores y constructores). Esta restricción de las funcionesdisponibles para el player en combinación con su poder ilimitado paracombinar tales funciones modela un algoritmo orientado a objetos.

Por otra parte, el quizmaster que modela el problema de cómputo a re-solver (la tarea de eliminación), oculta la representación interna de los poli-nomios y sólo proporciona consultas, creadores y comandos (observadores yconstructores) para operar con tales polinomios. Se niega el acceso directoa la representación y el player no sabe si los polinomios están dados porcoecientes, circuitos aritméticos u otra estructura de datos. Por lo tanto,el quizmaster también modela la noción de ocultamiento de la información.


µ∗


N ∗

ω∗

OO

N

ω

OO

N ′

ω′

OO

M

µ

OO

θ

II

µ′

CC

θ′

UU

Figure 35: Modelo matemático para la eliminación orientada a objetos.

La gura 35 ilustra el modelo matemático donde quizmaster y playerinteractúan. La salida de las consultas (observadores) son modeladas conuna framed data structureM∗, que también es el modelo para la entrada delos constructores. Nuestro modelo para las consultas (observadores) resultaser una función σ : O → M∗, y para la salida Poly∗out de la gura 34 esun framed abstract data type carrier de polinomios O∗. Para creadores ycomandos (constructores) es una función θ∗ :M∗ → O∗. De manera similarpara Rep∗out es un framed data structure N ∗ y para la función de abstracciónabs∗ es una función ω∗ : N ∗ → O∗. Para capturar la naturaleza de N ∗ deser un resultado computacional introducimos la función µ :M∗ → N ∗ paramodelar la implementación del constructor θ∗. Finalmente, la composición


θ∗σ resulta ser nuestro modelo matemático de un algoritmo de eliminaciónorientado a objetos que implementa la función solve.

Al nal de esta sección nos preguntamos cuáles son las mejores cotasinferiores de complejidad posibles que podemos esperar para este tipo dealgoritmos de eliminación.


5 Selected Lower Complexity Bounds

In this section we are going to use our computation model developed inSection 4 to derive complexity lower bounds for selected computationalproblems.

5.1 Polynomial Interpolation

In this section we are going to consider four types of quiz game proto-cols which generalize the intuitive meaning of interpolation of families ofmultivariate and univariate polynomials.

5.1.1 Interpolation and Numerical Analysis

Numerical Analysis deals with the approximative treatment of nite data,as vectors or arrays (e.g. matrices) of real numbers. Methodologicallyit is based on Classical Analysis, Diophantine Approximation, and, insome extent, on Algebraic Complexity Theory and marginally also on nonarchimedean theories like padic analysis.

In applied mathematics, generally innite objects, as functions andmaps, are treated by Approximation Theory which deals with the fol-lowing situation: there are given a set of complicated functions, a set ofsimple approximants and a metric which establishes a link between bothsets. Given a complicated function f , the theoretic part of ApproximationTheory discusses the existence and uniqueness of a best approximant. Thenext question deals with more practical aspects such as which data of thecomplicated function f are required to determine and compute a best (orsimply good) approximant? If f is a function which maps reals into reals,the approximants may be special functions, e.g. rational or trigonometricfunctions. This gives rise to dierent types of approximation.

In this thesis we are only concerned with approximants which are poly-nomials, i.e. with polynomial approximation. According to [Ral70] theeld of polynomial approximation uses dierent techniques:

• Approximation by interpolation

• Least-squares method

• Error min-max method

Maybe the most important link between Approximation Theory andNumerical Analysis is represented by Interpolation Theory. Interpolationconstitutes the starting point to many methods in other areas of Numer-ical Analysis, e.g. in numerical dierentiation and solution of dierentialequations. Interpolation has also direct applications, following [Con65] in-terpolation is normally used to:


• integrate and dierentiate complicated functions replacing them bysimple interpolants,

• evaluate a function given by values at some xed points at an extrapoint.

In the present work we do not discuss the error associated with the ap-proximations which is a common subject in Numerical Analysis textbooks.We discuss interpolation just as an example for a programming task whichvisualizes an interaction between software engineering and computationalcomplexity.

5.1.2 Multivariate Polynomial Interpolation

Let us extend abstract data type Poly of Section 3.1 with the identityfunction of polynomials. An implementation of the identity function interms of the representation has no interesting characteristics, e.g., a simpleimplementation would consists in the identity function of the representa-tion. We can nd more interesting problems if we study an objectorientedimplementation of the identity function of polynomials. Such an implemen-tation should apply both queries (observers) and creators and commands(constructors), and combine them in order to produce the identity function(see e.g. Appendix A for another example of this kind of identity function).If we restrict our queries (observers) to the function evaluate which eval-uates a polynomial in a given point, an interpolation problem arises inthe combination of creators and commands (constructors) we should useto obtain the identity polynomial. In this section we are going to give aquiz game which captures the objectoriented implementation of functionidentity. Even more, we are going to see that our quiz game captures aninterpolation problem. Figure 36 below illustrates this description.

Poly∗out constructors(interpolation)

oo Poly inobservers(evaluate)

oo

object-oriented identity

vvidentity

// Polyout

Rep∗out

abs∗

OO

Slp in

abs

OO

identitySlp// Slpout

abs

OO

Figure 36: Objectoriented implementation of function identity.


Let be given a framed abstract data type carrier O, framed data struc-tures M and N , an abstraction function θ : M → O associated with ageometrically robust constructible map µ : M → N and a polynomialmap ω : N → O, and suppose that (θ, µ, ω) belongs to a given compatiblecollection H.

Let O′ := O, τ := idO, θ′ := θ, µ′ := µ, ω′ := ω and let be given a quiz

game protocol with winning strategy for this situation. Then the playerreturns for a given parameter instance u ∈M, a point v∗ of a suitable anespace such that v∗ represents θ(u). In other words, the player replaces thehidden representation u of θ(u) by a new representation v∗ which hecomputes from the quizmaster's answers to his questions. Figure 37 belowillustrates this protocol.

O∗ M∗oo

O τ := idO //oo O′

N ∗

∈

v∗︸︷︷︸new representation

OO

N

ω

OO

N ′

ω′

OO

M

∈

u︸︷︷︸hidden representation

µ

OO

θ

II

µ′

CC

θ′

TT

Figure 37: Hidden representation u and new representation v∗.

Figure 37 illustrates that our quiz game protocol solves in an objectoriented manner the computation task given by the map τ := idO.

In our quiz game the player is limited to ask questions about the poly-nomial θ(u) itself and computes from the quizmaster's answers his newrepresentation of θ(u). If the player's questions refer only to values of thepolynomial θ(u) at given inputs, the player solves an interpolation problemfor θ(u). Below we are going to make this aspect more precise.

Interpolation of a family easy to evaluate. Let us now analyse thefollowing concrete example of this general setting. Let l, n ∈ N be dis-crete parameters with 2

l2 ≥ n and let M := Cn+1. For t ∈ C1 and


u = (u1, . . . , un) ∈ Cn, let θ(t, u) be the polynomial

θ(t, u)(X) := t2l−1∑k=0

(u1X1 + · · ·+ unXn)k,

and let O := im θ. From equality 37 in Appendix C it is easy to deducethat the family of polynomials θ is evaluable by a robust arithmetic circuitof size 2n + 3l − 1 where 2n corresponds to the number of operationsto evaluate u1X1 + · · · + unXn and 3l − 1 corresponds to the number ofoperations to evaluate the sum expression. Observe that, for any t ∈ C1

and any u ∈ Cn, the polynomial θ(t, u) can be computed using 2l − 2essential multiplications. Thus there exists an injective ane linear mapµ :M→ C2n+3l−1 with constructible image N := µ(M) and a polynomialmap ω : N → O such that θ = ω µ holds. Hence O is a framed abstractdata type carrier and θ :M→O is an abstraction function of size 2n+3l−1associated with µ and ω. From Proposition 19, and the comment thatfollows it, we deduce that (θ, µ, ω) belongs to a suitable collection H ofabstraction functions.

Suppose that for the previously considered computation task given byθ and idO there is given a protocol with winning strategy for the quizgame. Thus we have a framed abstract data type carrier O∗, framed datastructuresM∗ and N ∗, an abstraction function θ∗ :M∗ → O∗ of the com-patible collection H, associated with a geometrically robust constructiblemap µ∗ :M∗ → N ∗ and a polynomial map ω∗ : N ∗ → O∗, and a surjectivegeometrically robust constructible map σ :M→M∗ such that by Lemma35 the identities θ = ω∗ µ∗ σ = θ∗ σ and O = O∗ hold.

O∗ M∗oo ooθ∗oo

µ∗

yy

O τ := idO //σoo O′

N ∗ ⊂ Cm

ω∗

OO

N ⊂ C2n+3l−1

ω

OO

N ′

ω′

OO

M⊂ Cn+1

µ

OO

θ

FF

µ′

::

θ′

SS

σ

cc

Figure 38: A quiz game for interpolation.

Figure 38 illustrates that the composition θ∗ σ is an objectorientedimplementation for the identity function idO. In this context, the map θ∗

(highlighted by a bold arrow) models an interpolation problem and the


map µ∗ which is a geometrically robust constructible map solves the corre-sponding interpolation task continuously.

Recall from Section 2.3.1 that we denote a lower complexity bound withthe Ω notation.

Thus, with previous notations and assumptions, we have the followingstatement.

Lemma 21. The size of N ∗ is of order 2Ω(ln).

The proof of Lemma 21 can be found in [BHM+16, Lemma 16] andimplies that the winning strategy of the quiz game under consideration isnecessarily inecient. Even more, the multivariate interpolation problemgiven by the map θ∗ requires an interpolation algorithm which necessarilyuses 2Ω(ln) arithmetic operations.

We formulate now this conclusion in a more general setting.

Theorem 22. ([BHM+16, Theorem 13]) Let L, n ∈ N with 2L4 ≥ n and

let OL,n be the abstract data type of all polynomials of C[X1, . . . , Xn] whichcan be evaluated using at most L essential multiplications. We think theabstraction function of OL,n represented by the corresponding generic com-putation and consider the task of replacing the given hidden representationof the elements of OL,n by a known one using a quiz game with winningstrategy. Then any such quiz game is inecient requiring an abstractionfunction of size 2Ω(Ln).

Interpolation from an identication sequence. We are now going toexplain the computational task of interpolating for L, n ∈ N the family ofpolynomials OL,n continuously. From Proposition 19 we deduce that thereexist for OL,n×OL,n (many) integer identication sequences of length m :=4(L+n+1)2 +2 and bit size at most 3L+1. Let us x for the moment suchan identication sequence γ = (γ1, . . . , γm) ∈ Zm×n and let σ : OL,n → Cm

be the map σ(f) := (f(γ1), . . . , f(γm)). Then σ is a polynomial map withconstructible image M∗ := σ(OL,n) and σ : OL,n → M∗ is bijective. Let

N ∗ be the constructible subset of C(2L+nn ) formed by the coecient vectors

of the elements of OL,n and let ω∗ : N ∗ → OL,n be the map which assigns toeach element of N ∗ the corresponding polynomial of C[X1, . . . , Xn]. Thenω∗ is a polynomial map and M∗ and N ∗ form framed data structures.According to [CGH+03, Corollary 3], there is a unique rational, regular(i.e., everywhere dened), constructible map µ∗ : M∗ → N ∗ which isstrongly continuous, whose composition ω∗ µ∗ with ω∗ is the inverse mapof σ : OL,n →M∗.

From Theorem 39 we deduce that µ∗ is geometrically robust. Let usconsider the framed abstract data type carriers O := OL,n and O∗ := OL,n,the framed data structuresM := C(L+n+1)2 , M∗ := σ(OL,n) and N ∗, the


polynomial map θ :M→O given by the generic computation correspond-ing to OL,n, the polynomial map ω∗ : N ∗ → O∗ and the geometricallyrobust constructible maps µ∗ :M∗ → N ∗, θ∗ := ω∗ µ∗, σ : O →M∗ andσ := σ θ. They form the following commutative diagram of geometricallyrobust constructible maps:

O σ //M∗ θ∗ //

µ∗

""

O∗

Mθ

OO

σ

<<

N ∗ω∗

OO

This diagram represents a quiz game protocol with winning strategy forthe situation considered at the beginning of this section.

On the other hand, the geometrically robust constructible map µ∗ :M∗ → N ∗ assigns to each element σ(f) = (f(γ1), . . . , f(γm)) of M∗ thecoecient vector µ∗(σ(f)) of the polynomial f , and therefore interpolatesf at the points γ1, . . . , γm ∈ Zn. We deduce from Theorem 39 that µ∗ iscontinuous with respect to the Euclidean topologies ofM∗ and N ∗. Thusµ∗ solves the corresponding interpolation task continuously. This solutionis also eective because µ∗ is constructible.

Given any identication sequence γ = (γ1, . . . , γm) for OL,n × OL,n,any continuous solution of the task to interpolate the elements of OL,nin the points γ1, . . . , γm may be depicted as in the commutative diagramabove with µ∗ and ω∗ representing a robust arithmetic circuit. Theorem22 implies now that such a solution requires necessarily the use of 2Ω(Ln)

arithmetic operations. This is the content of [GHMS11, Theorem 23].

5.1.3 Univariate Polynomial Interpolation

We are now going to analyse the three series of examples which general-ize univariate polynomial interpolation. To this end, let us x a discreteparameter D ∈ N. Let l := 6dlogD − 1e + 1, M := C1 and X be anindeterminate. For t ∈M, let

θD(t)(X) := (tD − 1)∑

0≤k≤D

tkXk.

We set OD := im θD. Observe that the family of polynomials θD isevaluable by a robust arithmetic circuit of size l (see Example 13 in Sec-tion 3.2). Thus there exists an injective ane map µD : M → Cl withconstructible image ND := µD(M) and a polynomial map ωD : ND → ODsuch that θD = ωD µD holds. Hence OD is a framed abstract data typecarrier and θD = M → OD is an abstraction function of size l associatedto µD and ωD. From Proposition 19, and the comment that follows it, wededuce that (θD, µD, ωD) belongs to a suitable collection H of abstractionfunctions.


For any t ∈ M, let θ′D(t) := θD(t), θ′′D(t) the derivative of θD(t) withrespect of the variable X, and θ′′′D(t) the indenite integral with respect toX, namely

θ′′D(t)(X) := (tD − 1)∑

1≤k≤D

ktkXk−1

and

θ′′′D(t)(X) := (tD − 1)∑

0≤k≤D

tk

k + 1Xk+1.

Let O′D := im θ′D, O′′D := im θ′′D and O′′′D := im θ′′′D. We consider thegeometrically robust constructible maps

τ ′D : OD → O′D, τ ′′D : OD → O′′D, τ ′′′D : OD → O′′′D,θD(t) 7→ θ′D(t), θD(t) 7→ θ′′D(t), θD(t) 7→ θ′′′D(t).

Suppose that there are given framed data structures N ′′D and N ′′′D of sizepolynomial in l, geometrically robust constructible maps µ′′D : M → N ′′Dand µ′′′D : M → N ′′′D , and polynomials maps ω′′D : N ′′D → O′′D and ω′′′D :N ′′′D → O′′′D, such that θ′′D : M → O′′D and θ′′′D : M → O′′′D are abstractionfunctions of the compatible collection H associated with µ′′D, ω

′′D and µ′′′D,

ω′′′D, respectively. Finally, let N ′D := ND, µ′D := µD and ω′D := ωD. Eachof the three items (θD, τ

′D) and (θD, τ

′′D) and (θD, τ

′′′D ) dene a computation

task for a quiz game. The following diagram illustrates this scenario. Noticethat θD, θ

′D, θ

′′D and θ′′′D have the same domain of denitionM.

OD O′D O′′D O′′′D

ND N ′D N ′′D N ′′′D

M M M M

τ ′D

identity

τ ′′D

derivative

τ ′′′D

integral

ω ω′ ω′′ ω′′′

µ µ′ µ′′D µ′′′D

θD θ′D θ′′D θ′′′D

Suppose that for any of these tasks, e.g., for that given by (θD, τ′D),

there is given a quiz game protocol with winning strategy. Thus we havea framed abstract data type carrier O∗, framed data structures M∗ andN ∗, an abstraction function θ∗ :M∗ → O∗ of the compatible collection H,associated with a geometrically robust constructible map µ∗ : M∗ → N ∗


and a polynomial map ω∗ : N ∗ → O∗, and geometrically robust con-structible maps σ : OD → M∗ and σ := σ θD such that the identitiesθ′D = ω∗ µ∗ σ θD = ω∗ µ∗ σ = θ∗ σ and O′D = O∗ hold. Thefollowing diagram in Figure 39 illustrates this quiz game protocol.

O∗ M∗θ∗oo

µ∗

~~

ODτ ′D //σoo O′D

N ∗

ω∗

OO

ND

ω

OO

N ′D

ω′

OO

M

σ

aa

µ

OO

θD

FF

µ′

BB

θ′D

UU

Figure 39: A quiz game for map τ ′D.

Lemma 23. The size of N ∗ is at least D + 1.

A proof of Lemma 23 can be found in [BHM+16, Lemma 19].

Any polynomial f over C requires at least log(deg f) essential multipli-cations to be evaluated by an ordinary divisionfree arithmetic circuit (seee.g. [BCS978.1]). Let (θD)D∈N be the sequence of families of univariatepolynomials considered before. Observe that for any t ∈M, the univariatepolynomial θD(t) can be evaluated by an ordinary divisionfree arithmeticcircuit of size O(logD) (see Appendix C) and that deg θD(t) ≤ D holds.For all but nitely many t ∈ M we have deg θD(t) = D. In this sense,(θD)D∈N is a sequence of families of univariate polynomials which are easyto evaluate. From Lemma 23 we deduce now the following less technicalstatement.

Theorem 24. ([BHM+16, Theorem 16]) There exists a sequence of fam-ilies of univariate polynomials which are easy to evaluate such that thecontinuous interpolation of these polynomials, or their derivatives, or theirindenite integrals, requires an amount of arithmetic operations which isexponential in the number of essential multiplications of the most ecientordinary divisionfree arithmetic circuits which evaluate these polynomials.

Theorem 24 extends [GHMS11, Proposition 22], and simplies its proof.


5.2 Elimination

We are going to analyse two series of examples of geometric eliminationproblems from the point of view of quiz games. The rst one is concernedwith a parameterized family of elimination problems dened on a xedhypercube and the second one is related to the computation of characteristicpolynomials in linear algebra.

5.2.1 A Parameterized Family of Projections of a Hypercube

Let n ∈ N be a discrete parameter and let M := Cn+1. Let X :=X1, . . . , Xn, Y be indeterminates over C. For t ∈ C1 and u = (u1, . . . , un) ∈Cn, let θ(t, u) and θ′(t, u) be the following polynomials:

θ(t, u)(X) :=∑

1≤i≤n

2i−1Xi + t∏

1≤i≤n

(1 + (ui − 1)Xi), (18)

θ′(t, u)(Y ) :=∏

ε∈0,1n

(Y − θ(t, u)(ε)

)(19)

Observe that∏ε∈0,1n

(Y − θ(t, u)(ε)

)=

∏0≤j<2n

(Y −

(j + t

∏1≤i≤n

u[j]ii

))(20)

where [j]i denotes the ith digit of the binary representation of the integerj for 0 ≤ j < 2n and 1 ≤ i ≤ n.

Now we prove equation (20) which was introduced in [CGH+03]. Ob-serve that the polynomial ∏

ε∈0,1n

(Y − θ(t, u)(ε)

)evaluates θ(t, u)(X) in points ε ∈ 0, 1n. Thus the variables X1, . . . , Xn

are only evaluated in zeroes or ones. The eect of this evaluation is thatthe variable Xi has the role of a selector which in equation (18) the term∑

1≤i≤n

2i−1Xi

adds the term 2i−1 only if the variable Xi is one. Therefore each point ε isa binary codication of a number which corresponds to the value j of thepolynomial ∏

0≤j<2n

(Y −

(j + t

∏1≤i≤n

u[j]ii

))


in equation (20). The polynomial equations (X2i −Xi = 0)1≤i≤n will force

the variables X1, . . . , Xn to acquire the value 0 or 1 in equation (22) below.On the other hand, equation (18) also adds the product of a subset of

the parameters u1, . . . , un, this subset is given by the values of Xi, namely,if Xi is one, the parameter ui is added to the product, otherwise a fac-tor one is added to the product. The whole product is nally multipliedby the parameter t. This logic which corresponds to instructions of anyprogramming language is codied by the algebraic term

t∏

1≤i≤n

(1 + (ui − 1)Xi︸︷︷︸

if Xi = 0..then 1..else ui

)(21)

Recall that each point ε ∈ 0, 1n is a binary number whose decimal valueis given by j. Thus, if we specialize in (21) the variable X = (X1, . . . , Xn)in ε, the following equality holds

t∏

1≤i≤n

1 + (ui − 1)Xi = t∏

1≤i≤n

u[j]ii

This equality proves (20).We are now going to formulate an elimination problem in terms of

polynomials θ and θ′ in equations (18) and (19) respectively.Let O := im θ, O′ := im θ′, N := M, µ := idM, ω := θ and observe

that the family of polynomials θ is evaluable by a robust arithmetic circuitof size 5n. We may therefore deduce from Proposition 19, and the commentfollowing it, that (θ, µ, ω) belongs to a suitable compatible collection Hof abstraction functions. We suppose that θ′ is an abstraction functionassociated with a geometrically robust constructible map µ′ : M → N ′and a polynomial map ω : N ′ → O′, such that (θ′, µ′, ω′) belongs to thecompatible collection H.

Observe that for t ∈ C1 and u ∈ Cn, the formulas

(∃X1) . . . (∃Xn)(X21 −X1 = 0 ∧ · · · ∧X2

n −Xn = 0∧Y − θ(t, u)(X1, . . . , Xn) = 0)

(22)

and

θ′(t, u)(Y ) = 0 (23)

are logically equivalent. In fact,

θ′(t, u)(Y ) =∏

ε∈0,1n(Y − θ(t, u)(ε))


is the elimination polynomial of the projection of the hypercube 0, 1nalong θ(t, u). Therefore there exists a geometrically robust constructiblemap τ : O → O′ such that τ θ = θ′ holds.

Suppose now that for the computation task determined by θ and τthere is given a winning strategy of the quiz game protocol. Thus we havea framed abstract data type carrierO∗, framed data structuresM∗ andN ∗,an abstraction function θ∗ of the compatible collection H, associated witha geometrically robust constructible map µ∗ :M∗ → N ∗ and a polynomialmap ω : N ∗ → O∗, and a surjective geometrically robust constructible mapσ :M→M∗ such that by Lemma 35 the identities θ′ = ω∗ µ∗ σ = θ∗ σand O′ = O∗ hold.


µ∗

yy


N ∗ ⊂ Cm

ω∗

OO

N ⊂ C5n

ω

OO

N ′

ω′

OO

M⊂ Cn+1

µ

OO

σ

dd

θ

II

µ′

<<

θ′

SS

Figure 40: An example of objectoriented elimination.

Figure 40 shows that the composition θ∗ σ models an objectorientedalternative for the computation task τ and the identity

θ′ = ω∗ µ∗ σ θ

holds. Let m be the dimension of the ambient space of N ∗ (N ∗ ⊂ Cm).Theorem 25 below states a lower bound for this value m.

Theorem 25. Let notions and notations be as before. The size of N ∗ isat least 2n.

Proof. Let T, U1, . . . , Un be new indeterminates, U := (U1, . . . , Un) and let

F :=∏

0≤j<2n

(Y −

(j + T

∏1≤i≤n

U[j]ii

))

We rewrite F as follows

F = Y 2n +B1Y2n−1 + · · ·+B2n


with Bk ∈ C[T, U ] for 1 ≤ k ≤ 2n. Arguing as in [CGH+03, Section 4.2]we deduce that for 1 ≤ k ≤ 2n, the coecient Bk is of the form

Bk = (−1)k∑

0≤j1<···<jk<2n

j1 . . . jk + TLk + terms of higher degree in T ,

where L1, . . . , L2n ∈ C[U ] = C[U1, . . . , Un] are Clinearly independent.Therefore there exists a nonempty Zariski open subset Z of C2n×n suchthat for any point (u1, . . . , u2n) ∈ Z with u1, . . . , u2n ∈ Cn, the (2n × 2n)matrix

NL1,...,L2n:=

L1(u1) . . . L1(u2n)...

. . ....

L2n(u1) . . . L2n(u2n)

(24)

is nonsingular.Since any u ∈ Cn satises the condition

θ(0, u) =∑

1≤i≤n

2i−1Xi

we conclude that θ(0, u) is constant.Thus, the value (µ∗ σ)(θ(0, u)) is the same, say v, for any u ∈ Cn+1.The maps µ∗ σ θ : M → N ∗ and θ′ : M → O∗ are geometrically

robust and constructible, and hence polynomial becauseM is smooth (seeTheorem 38(iii)). For 1 ≤ k ≤ 2n and t ∈ C1, let

εk(t) := (µ∗ σ)(θ(t, uk)) and δk(t) := θ′(t, uk).

Since θ′ = ω∗ µ∗ σ θ, we deduce δk = ω∗ εk. To this composition wemay apply the chain rule to conclude that

dδkdt

(0) = dω∗(εk(0)) · dεkdt

(0). (25)

Observe that εk and δk are polynomial maps with domain of denition C1

and therefore holomorphic. Moreover we have εk(0) = (µ∗σ)(θ(0, uk)) = vfor 1 ≤ k ≤ 2n. Thus (25) implies

dδkdt

(0) = dω∗(v) · dεkdt

(0). (26)

Observe now that L1(u), . . . , L2n(u) are the coecients of the polynomial∂F∂T

(0, u). This implies that

dδkdt

(0) =∂θ′

∂t(0, uk) =

(L1(uk), . . . , L2n(uk)

)A. A. Rojas Paredes 90

for 1 ≤ k ≤ 2n. Then (26) takes the form

(L1(uk), . . . , L2n(uk)

)= dω∗(v) · dεk

dt(0). (27)

Let M be the Jacobi (m×2n)matrix corresponding to dω∗(v) in matricialform, let NL1,...,L2n

be the (2n × 2n)matrix in (24) and let

K :=

dε1dt

(0)...

dε2ndt

(0)

(28)

be a (2n ×m)matrix. Then (27) implies the matrix identity

NL1,...,L2n= K · M

From the nonsingularity of NL1,...,L2nwe deduce that K generates a Clinear

space of dimension 2n. This implies that the rank of M is at least 2n, i.e.,m ≥ 2n. Therefore the size of N ∗ is at least 2n.

Remark 26. According to our objectoriented interpretation of compositionθ∗ σ in Figure 40 above, Theorem 25 becomes a lower bound for the com-plexity of any robust objectoriented elimination algorithm implementingcomputation task τ . Moreover, Theorem 25 shows a parameterized familyof elimination problems where there is no class interface of polynomials (inthe objectoriented paradigm) which may be divided into creators, com-mands and queries (constructors and observers) such that such an interfacemay be used to solve the given elimination problem in an ecient way. Thisconclusion suggests an intrinsic limit for the software designer of modules,class interfaces, and abstract data types of polynomials. This limit is verysimilar to a computability result but a little more specic because it refersto the ability to make an ecient software.

Representation of Elimination Polynomials

We are now going to elaborate on an important aspect of the family ofexamples in the previous section. Observe that any polynomial θ(t, u)(X)can be evaluated in X by a divisionfree arithmetic circuit using n − 1essential multiplications. From [GHMS11, Section 3.3.3] we deduce thefollowing facts:there exist K := 16n2 + 2 points ξ1, . . . , ξK ∈ Zn of bit length at most 4nsuch that for any two polynomials f, g ∈ O, the equalities

f(ξ1) = g(ξ1), . . . , f(ξK) = g(ξK)


imply f = g. Thus the polynomial map σ : O → CK dened by

σ(f) := (f(ξ1), . . . , f(ξK))

is injective. Moreover M∗ := σ(O) is an irreducible constructible subsetof CK . Finally the constructible map Φ := σ−1 which mapsM∗ onto O isgeometrically robust.

For ε ∈ 0, 1n, we denote by Φε :M∗ → C1 the map Φε(v) := Φ(v)(ε).One sees easily that Φε is a geometrically robust constructible function.Observe that the identities

Φε(σ(θ(t, u))) = Φ(σ(θ(t, u))(ε)) = (σ−1 σ)(θ(t, u))(ε) = θ(t, u)(ε)

hold for any t ∈ C1 and u ∈ Cn.

Thus, the following diagram commutes for every (t, u) ∈M.

C1

M∗Φ := σ−1

//

Φε --

Oevaluate in ε

==

σ := evaluate in ξ1,...,ξKoo

Mθ

OO

Figure 41: Two kinds of polynomial evaluation.

For a given point v ∈M∗, let

P (v, Y ) :=∏

ε∈0,1n(Y − Φε(v)) :=

∏ε∈0,1n

(Y − Φ(v)(ε))

and let O∗ := P (v, Y ) : v ∈ M∗. Then the coecients of P withrespect to Y are geometrically robust constructible functions with domainof denition M∗ and O∗ is a framed abstract data type carrier. Hencethe map θ∗ : M∗ → O∗, θ∗(v) := P (v, Y ) is geometrically robust andconstructible. Suppose now that there is given a framed data structureN ∗ and that θ∗ is an abstraction function associated with a geometricallyrobust constructible map µ∗ :M∗ → N ∗ and a polynomial map ω∗ : N ∗ →O∗, such that (θ∗, µ∗, ω∗) belongs to the compatible collection H.

Figure below illustrates the construction of framed abstract data typecarrier O∗.


O∗

N ∗ω∗

OO

C1

M∗

µ∗

OOθ∗

CC

Φ := σ−1//

Φε --

Oevaluate in ε

==

σ := evaluate in ξ1,...,ξKoo

Mθ

OO

Figure 42: An interesting framed abstract data type carrier of polynomials.

From the identities

P (σ(θ(t, u)), Y ) =∏

ε∈0,1n(Y − Φε(σ(θ(t, u))))

=∏

ε∈0,1n(Y − θ(t, u)(ε))

= θ′(t, u)

we deduce that ω∗ µ∗ σ θ = θ∗ σ θ = θ′ holds. This means thatσ and (θ∗, µ∗, ω∗) dene a winning strategy for the quiz game protocol ofthe computation task given by θ and τ . This implies by Theorem 25 thatthe size of N ∗ is at least 2n. In other words, any representation of thepolynomial P has size exponential in n.

Additionally, we may interpret abstraction function θ∗ as a creator orcommand (constructor) and the map σ as a query (observer) applied to O.Thus, the composition σ θ∗ becomes an objectoriented implementationfor the computation task given by the map τ . Figure 43 below illustratesthis interpretation of the maps θ∗ and σ which becomes highlighted by boldarrows.

A Natural Elimination Object

We argue now that the polynomial P is a natural elimination object. Let

Θ(T, U,X) :=∑

1≤i≤n

2i−1Xi + T∏

1≤i≤n

(1 + (Ui − 1)Xi)


C1

O∗ M∗

µ∗||

ooooθ∗oo

Φ := σ−1//

Φε --

O

==

τ//oooo

σ := evaluate in ξ1,...,ξKoo O′

N ∗ω∗

OO

Mθ

OO

θ′

NN

Figure 43: An unexpected winning strategy.

and let V1, . . . , Vk be new indeterminates. Observe that the existentialrstorder formula

(∃X1) . . . (∃Xn)(∃T )(∃U1) . . . (∃Un)( ∧1≤i≤n

X2i −Xi = 0 ∧

∧1≤k≤K

Vk = Θ(T, U, ξk) ∧ Y = Θ(T, U,X)

)(29)

describes the constructible subset

(v, y) ∈ CK+1 : v ∈M∗, y ∈ C, P (v, y) = 0

of CK+1. Interpreting the coecients of P as elements of the function eldC(M∗

) of the irreducible algebraic variety M∗, one sees easily that P is

the greatest common divisor in C(M∗)[Y ] of all polynomials of C[M∗

][Y ]which vanish identically on the constructible subset of CK+1 dened byformula (29). Hence P is an elimination polynomial parameterized byM∗.

Observe that the polynomials contained in the formula (29) can berepresented by a robust arithmetic circuit of size O(n3). Therefore theformula (29) is also of size O(n3). Thus we have proved the followingstatement.

Theorem 27. Let n ∈ N be a discrete parameter. There exists a rstorderformula of size O(n3) of the elementary theory of C determining a frameddata structureM∗ of size O(n2) and a family P of univariate eliminationpolynomials parameterized byM∗ such that the following holds. Let O∗ bethe framed abstract data type carrier dened by the family of polynomialsP and θ∗ :M∗ → O∗ the representation of O∗ given by the parameteriza-tion of P . Then θ∗ is a surjective geometrically robust constructible map.Moreover, for any framed data structure N ∗ and any geometrically robustconstructible map µ∗ :M∗ → N ∗ and any polynomial map ω∗ : N ∗ → O∗,such that (θ∗, µ∗, ω∗) determines an abstraction function associated with µ∗

and ω∗, the size of N ∗ is at least 2n.


Theorem 27 states that polynomial size formulas may produce elimi-nation polynomials of exponential size for any (reasonable) representation.This conclusion is essentially the content of [CGH+03, Theorem 4] (see also[GH01, Theorem 5], [HKRP13b, Theorem 15] and [HKRP13a, Theorem 8]).

The leading idea of the proof of Theorem 27 was to use an existentialformula, namely (29), to encode a suitable interpolation problem whosesolution is the interpolation polynomial P ∈ C(M∗

)[Y ]. This encodingrelates elimination with interpolation in the sense of Section 5.1 and ex-plains the similarity of the proofs of Theorem 22 and Theorem 25. In fact,the example exhibited in the proof of Theorem 27 entails nothing but ahardness result for a suitable interpolation of a polynomial family, given byΘ, on the constructible setM∗. Using formula (29) we obtain nally ourhardness result for elimination, namely Theorem 27.

5.3 Other Applications

5.3.1 Neural Networks with Polynomial Activation Functions

In this section we will freely use well established terminology on neu-ral networks (see e.g. [HKP91], [HDB96] and [HKP99]). Let n ∈ N,u1, . . . , un, t ∈ C be discrete parameters. Let X1, . . . , Xn, Y1, Y2 and Yindeterminates. We consider the following two layer neural network:

Figure 44: A neural network.

Figure 44 above describes, according to the graphical notation for neuralnetworks in [HKP99], a twolayer perceptron with two neurons, a weightvector (t, u1, . . . , un), inputs X1, . . . , Xn, one output Y2, two activationfunctions

ϕ1(Y ) := Y n and ϕ2(Y ) := Y,

and intermediate values

v1 :=∑

1≤i≤n

uiXi and v2 := tY1.


Observe that the output Y1 of neuron 1 satises the following equalities

Y1 = ϕ1(v1) = ϕ1(∑

1≤i≤n

uiXi) = (u1X1 + · · ·+ unXn)n.

Thus, the output of neuron 2 satises the equalities

Y2 = ϕ2(v2) = ϕ2(tY1) = ϕ2(t(u1X1 + · · ·+ unXn)n)

= t(u1X1 + · · ·+ unXn)n.(30)

Let u := (u1, . . . , un), observe that formula (30) dening the output of ourneural network describes a framed abstract data type carrier of polynomials

O := t(u1X1 + · · ·+ unXn)n : (t, u) ∈ Cn+1. (31)

Observe that the polynomials in O are evaluable by a robust arith-metic circuit of size 2n + 2dlog ne. Thus, our neural network in Figure44 above is evaluable with 2n + 2dlog ne arithmetic operations. We maytherefore deduce that there exists a framed data structure N ⊂ C2n+2dlogne

and a polynomial map ω which sends N into O. Observe also that thereexists a framed data structure M ⊂ Cn+1 such that a geometrically ro-bust constructible map µ :M→N reparametrizes framed data structuresN . Therefore there exists an abstraction function θ : M → O associ-ated to µ and ω, such that (θ, µ, ω) belongs to a compatible collection Hof abstraction functions. Even more, our abstraction function θ denesfor each weight vector instance (t, u1, . . . , un) a polynomial target functionθ(t, u)(X) = t(u1X1 + · · ·+ unXn)n

Paraphrasing [Fla98], the learning of a target function θ(t, u) is simplya matter of setting the weights by means of a backpropagation algorithm(see [HKP91, Chapter 6.1]) such that the output of the neural network isthe function θ(t, u). The learning process starts with initial weights (t0, u0)and ends with the weights (t, u). Figure 45 below describes this process.

Figure 45: Learning function θ(t, u).

The learning of a target function θ(t, u) can also be interpreted as thetask of interpolating the function θ(t, u), e.g., given a target function θ(t, u)we can obtain a suitable quantity of random points of the function θ(t, u)such that from these points and no other information our neural networklearns the target function θ(t, u). Then, we ask whether our neural network


in Figure 44 above is able to learn (or interpolate) every polynomial in theframed abstract data type carrier O of (31).

Suppose that for the previous computation task there is given a quizgame protocol with winning strategy. Thus we have a framed abstractdata type carrier O∗, framed data structuresM∗ and N ∗, an abstractionfunction θ∗ : M∗ → O∗ of the compatible collection H, associated with ageometrically robust constructible map µ∗ : M∗ → N ∗ and a polynomialmap ω∗ : N ∗ → O∗, and a surjective geometrically robust constructiblemap σ : O → M∗ such that the identities θ = ω∗ µ∗ σ θ = θ∗ σ θand O∗ = O hold.

Lemma 28. Let notions and notations be as before. The size of the frameddata structureM∗ is at least

(2n−1n−1

)≥ 2n−1.

A proof of Lemma 28 can be found in [BHM+16, Lemma 17].Suppose now that our neural network is able to learn continuously for

n > 3 every polynomial in the framed abstract data type carrier O. Thenthere exists a geometrically robust constructible map σ : O → M suchthat the identity θ = θ σ θ holds. This contradicts Lemma 28 withM∗ := im (σ θ) and N ∗ :=M∗, because in this case the size of N ∗ is atmost n+1, which is strictly smaller than 2n−1. Lemma 28 implies thereforethe following learning result for neural networks.

Theorem 29. ([BHM+16, Theorem 18]) Let n ∈ N be a discrete param-eter. Let O be the framed abstract data type carrier of polynomials in(31). There exists a twolayer neural network with two neurons, n inputs,one output and two polynomial activation functions which can be evaluatedusing 2dlog ne essential multiplications, such that there is no continuousalgorithm able to learn exactly the polynomials in O.

Theorem 29 implies that our neural network in Figure 44 above can-not learn in a continuous manner the polynomials in framed abstract datatype carrier O. We conrmed this theoretical conclusion by computer ex-periments with the 8.3 Matlab version of the standard backpropagationalgorithm which we adapted especially to the case of polynomial activationfunctions.

Denition 30 (Concept Class). In computational learning theory a con-cept class is a set of learnable functions.

Theorem 22 may be paraphrased in terms of learning theory as follows.

Corollary 31. ([BHM+16, Corollary 14]) For L, n ∈ N with 2L4 ≥ n, the

concept class OL,n has a representation of size (L + n + 1)2 by means ofthe corresponding generic computation, but its concepts require an amountof 2Ω(Ln) arithmetic operations to be learned continuously.


5.3.2 Applications in Software Engineering

According to SEMAT7, the initiative to reshape software engineering toqualify as a rigorous discipline, the three main activities in software con-struction are specication, design and implementation. In this section weargue that our computation model can be used in the design activity whena software design should satisfy a certain complexity requirement. Thefollowing example illustrates this application.

Let us suppose that we want to implement the membership function(∈) of an abstract data type of nite sets. Suppose that this abstract datatype is implemented by a class Set with choice of representation given byunordered arrays implemented by a class Array. According to the graphicalnotation of class diagrams in UML we have used in this thesis, we obtainFigure 46 a) which is a preliminary software design for our membershipproblem.

Set

Array

(a) First option

Set

Sorted Array

(b) Second option

Figure 46: Two designs for the membership problem of nite sets.

Suppose now that we have to satisfy the requirement that membershipto a set of cardinality n should be decided using only O(log(n)) compar-isons. A simple observation suggests that with software design in Figure 46a) we want to search in worst case at every position of the array to decidemembership. Thus it may be impossible to satisfy the given complexityrequirement O(log(n)) by means of the previously xed software design.Therefore we discard this rst design and we propose an implementation interms of sorted arrays, i.e., Figure 46 b) above. In this case we are allowedto satisfy our complexity requirement, e.g., by means of the binary searchalgorithm.

The impossibility conclusion which allowed us to discard a design inFigure 46 a) was mainly inferred by means of intuition. Unfortunately,intuition is not a precise and rigorous method like the one SEMAT requiresfor Software Engineering. In this sense, our computation model providessuch a precision and allows us to evaluate a software design with respect to

7SEMAT (Software Engineering Method and Theory) was launched in December2009 by Ivar Jacobson, Bertrand Meyer, and Richard Soley.


a given computation task and a complexity requirement. In Sections 3 and4 we illustrated this application of our model by means of a problem calledquantier elimination in elementary geometry of algebraically closed eldsof characteristic zero. We explain now this application more explicitly.

Poly

solve()

Slp

(a) First option

Poly

?

(b) Second option

Poly

observers()

constructors()

Hidden

(c) Third option

Figure 47: Our model evaluates a software design.

Let us recall that an elimination algorithm was modelled by means ofan abstract data type of multivariate polynomials called Poly and a func-tion belonging to this abstract data type called function solve. Recall alsothat Poly is an abstract data type and is therefore a mathematical notionwhich becomes implemented by a class Poly with a choice of representa-tion given by arithmetic circuits. Suppose that these arithmetic circuitsare implemented in a class called Slp. Thus, we may graphically describePoly and Slp in Figure 47 (a) which is the software design behind circuitbased elimination algorithms. Now we ask whether function solve can becomputed in less than exponentially many operations, the current worstcase complexity for the particular elimination problems we considered inthis thesis. The answer is no if our algorithms are based in the design inFigure 47 (a) and also satisfy the non-functional requirement of robustnessgiven by its more precise instance which is a continuity requirement (seeSection 3).

Figure 47 suggests that we have to discard our previously xed design(a) and propose another implementation of polynomials. Unfortunately, wedo not know implementations of polynomials which are more ecient thanarithmetic circuits. We emphasize this situation with a question mark inFigure 47 (b). Our computation model allows us to evaluate and discarddesign (a), now it is a task for the software engineer to nd a suitablealternative design.

According to Section 4.1, an alternative to deal with unknown datastructures is to use objectoriented programming and information hiding.Thus, we hide the representation of polynomials as Figure 47 (c) suggestsand we dene our algorithms in terms of queries (observers) and creatorsand commands (constructors) of the abstract data type Poly. Notice that


we do not x in advance the software design, but we x the tools availablefor the programmer, namely, the interface of the abstract data type Poly. Inthis sense, our computation model allows us to discard an interface which isdivided into creators, commands and queries (constructors and observers)(see Remark 26 in Section 5.2.1).


Cotas Inferiores de Complejidad

En la Sección 5 aplicamos nuestro modelo de cómputo de quiz games quefue desarrollado en la Sección 4 para derivar cotas inferiores de complejidadpara problemas computacionales seleccionados.

Interpolación

En la Sección 5.1 se generaliza el signicado intuitivo de la interpolación defamilias de polinomios multivariados y univariados. No se discute el errorasociado con las aproximaciones que es un tema común en los libros de textode Análisis Numérico. En cambio, se discute la interpolación como ejemplode una tarea de programación que sirve para visualizar una interacción entrela Ingeniería de Software y la Complejidad Computacional.

Eliminación

En la Sección 5.2 se analizan dos series de problemas de eliminación desdeel punto de vista de los quiz games. La primera se reere a una familiaparametrizada de los problemas de eliminación denidos en un hipercubojo y el segundo está relacionado con el cálculo de polinomios característicosen álgebra lineal.

En esta sección presentamos nuestro resultado principal, el Teorema 25,y lo discutimos como una cota inferior de complejidad para cualquier al-goritmo robusto de eliminación orientado a objetos. Además, este teoremamuestra una familia parametrizada de problemas de eliminación donde nohay una interfaz de clases de polinomios (en el paradigma orientado a obje-tos) que se puede dividir en creadores, comandos y consultas (constructoresy observadores), de tal manera que tal interfaz pueda ser utilizada para re-solver un problema de eliminación de una manera eciente. Esta conclusiónsugiere un límite intrínseco para el diseñador de módulos de software, inter-faces de clase y tipos abstractos de datos de polinomios. Este límite es muysimilar a un resultado de computabilidad, pero un poco más especíco, yaque se reere a la capacidad de hacer un software eciente.

Redes Neuronales

En la Sección 5.3.1 se usa libremente la terminología de redes neuronales(ver [HKP91], [HDB96] y [HKP99]). El teorema 29 implica que existe unared neuronal con funciones de activación polinomiales que no puede apren-der de manera continua los polinomios del tipo abstracto de datos. Estaconclusión teórica fue conrmada por experimentos informáticos con laversión 8.3 Matlab del algoritmo estándar de retropropagación, que hemosadaptado especialmente al caso de las funciones de activación polinomial.


Diseño de Software

Finalmente discutimos nuestro modelo de cómputo desde el punto de vistade sus aportes al campo de la Ingeniería de Software. Nuestro modelo puedeser una herramienta para mejorar por adelantado el diseño de un software,podría ser una herramienta para el programador y para el análisis de susprogramas, en el caso que hemos estudiado en esta tesis: sus programasestán determinados por la interfaz del tipo abstracto de datos Poly. En estesentido, nuestro modelo de cómputo nos permite descartar una interfaz enbase a requerimientos de complejidad.


6 Approximative Algorithms and

Concluding Remarks

6.1 Approximative Algorithms

The main purpose of this section is to generalize our protocol for quizgames by means of information of approximative nature. For this purpose,we rst introduce a representation of polynomials given by approximativeinformation, namely by approximative parameter instances. This approx-imative representation provides motivation for our second protocol, whichis called approximative quiz game.

6.1.1 Approximative Parameter Instances

Let O be a framed abstract data type carrier, M and N framed datastructures, θ :M→O a surjective geometrically robust constructible map,µ : M → N a geometrically robust constructible map and ω : N → Oa polynomial map such that θ = ω µ holds. Thus θ is an abstractionfunction associated with µ and ω. Suppose that the elements of O arepolynomials of C[X1, . . . , Xn], where X1, . . . , Xn are indeterminates.

Let U1, . . . , Ur be new indeterminates, where r is the size ofM, and letU := (U1, . . . , Ur) and X := (X1, . . . , Xn). Let a be the vanishing ideal ofM in C[U ] and let us x a polynomial P ∈ C[U ] such that MP := u ∈M : P (u) 6= 0 is a Zariski open and dense subset ofM (from the ChineseRemainder Theorem one deduces easily that such a polynomial P exists).Let ε be a new indeterminate.

Denition 32. An approximative parameter instance for θ is a vectoru(ε) = (u1(ε), . . . , ur(ε)) ∈ C((ε))r which constitutes a meromorphic mapgerm at the origin such that any polynomial of a vanishes at u(ε) andP (u(ε)) 6= 0 holds.

Let u(ε) be an approximative parameter instance for θ. Then thereexists an open disc ∆ around 0 such that for any complex number c ∈∆\0 the germ u(ε) is holomorphic at c and such that P (u(c)) 6= 0 holds.This implies that any polynomial of a vanishes at u(c). In particular, u(c)belongs toM for any c ∈ ∆ \ 0.

For technical reasons we need the following result whose proof can befound in [BHM+16].

Lemma 33. Let u(ε) be an approximative parameter instance for θ. Thenthere exists an open disc ∆ of C around the origin and a germ ψ of mero-morphic functions at the origin such that u(ε) and ψ are holomorphic on∆ \ 0 and such that any complex number c ∈ ∆ \ 0 satises the condi-tions P (u(c)) 6= 0 and ψ(c) = µ(u(c)).


Let u(ε) be an approximative parameter instance for θ. Then followingLemma 33 there exists an open disc ∆ of C around the origin such thatµ(u(ε)) is meromorphic on ∆ and holomorphic on ∆ \ 0. Thereforethe coecients of the polynomial θ(u(ε)) := ω(µ(u(ε))) with respect to Xhave the same property. Thus θ(u(ε)) can be interpreted as an element ofC((ε))[X].

We say that the approximative parameter instance u(ε) for θ encodesa polynomial H ∈ C[X] if there exists a polynomial H ′ ∈ C[[ε]][X], whosecoecient vector with respect to X constitutes a germ of functions whichare holomorphic at the origin, such that θ(u(ε)) can be written in C((ε))[X]as

θ(u(ε)) = H + εH ′.

The mere existence of an encoding of a given polynomial by an approxi-mative parameter instance for θ becomes characterized as follows.

Theorem 34. ([BHM+16, Theorem 28]) Let notations and assumptions beas before and let H ∈ C[X]. Then the following conditions are equivalent:

(i) There exists an approximative parameter instance for θ that encodesthe polynomial H.

(ii) There exists a sequence (uk)k∈N inM such that (θ(uk))k∈N convergesto H in C[X].

(iii) H belongs to O.

Theorem 34 suggests that we may consider a (not necessarily conver-gent) sequence (uk)k∈N in M such that (θ(uk))k∈N converges in the Eu-clidean topology to a polynomial H ∈ C[X1, . . . , Xn] as an approximativeencoding of H with respect to θ. This motivates the approximative quizgame of the next section.

A symbolic variant of Theorem 34 for the representation of polynomi-als by robust arithmetic circuits with parameter domain Cr is the maintechnical contribution of [Ald84] (see also [Lic90A]).

6.1.2 The Protocol of the Approximative Quiz Game

Now we introduce the protocol of the approximative quiz game. As thegame follows almost the same rules as in the exact case (quiz game denedin Section 4), we shall therefore only stick on the dierences.

The quizmaster's answers to the player's questions are now representedby a geometrically robust constructible map σ with domain of denitionM. We do not anymore assume that σ is a composition of θ with anothermap . This situation is depicted by Figure 48 below.


O∗ M∗θ∗oo

µ∗

O τ // O′

N ∗

ω∗

OO

N

ω

OO

N ′

ω′

OO

M

bb bb

σ

bb

µ

OO

θ

II

µ′

CC

θ′

UU

Figure 48: Quiz game for an approximative algorithm.

We suppose that the quizmaster is able to evaluate σ. As before letM∗ := σ(M) and assume that there is given a framed abstract data typecarrier O∗ and an abstraction function θ∗ : M∗ → O∗, associated with ageometrically robust constructible map µ∗ : M∗ → N ∗ and a polynomialmap ω∗ : N ∗ → O∗, from the compatible collection H, such that θ∗ =ω∗ µ∗.

We suppose that the following condition is satised:

For any (not necessarily convergent) sequence (uk)k∈N in M and u ∈M such that (θ(uk))k∈N converges to θ(u) in the Euclidean topology, thesequence

((µ∗ σ)(uk)

)k∈N is bounded.

We remark that this condition is satised if and only if the map µ∗ σ : M → N ∗ is locally bounded with respect to the Euclidean metric ofN ∗ and the topology ofM induced from the Euclidean topology of O byθ :M→O. As we shall see in Proposition 36 below, this implies that forany u ∈M the value (µ∗ σ)(u) strongly depends on θ(u), although it maybe not uniquely determined by θ(u).

The quizmaster chooses now a sequence (uk)k∈N inM and an elementu ∈ M such that (θ(uk))k∈N converges to θ(u), and hides these data tothe player. The quizmaster's answers to the player's questions encode thesequence (σ(uk))k∈N, which is not necessarily convergent. From these an-swers the player infers the sequence

((µ∗ σ)(uk)

)k∈N, which is bounded.

The player wins the approximative game if there is an accumulation pointv∗ of

((µ∗ σ)(uk)

)k∈N in the Euclidean topology with ω∗(v∗) = θ′(u). The

quizmaster veries this by computing v′ := µ′(u) and checking whetherω∗(v∗) = ω′(v′) holds.

Recall that the computational task determined by θ and θ′ is calledfeasible if the size of θ′ is polynomial in the size of θ. Again we say thatthe player has a winning strategy if he wins for any u ∈ M, and we callthis winning strategy ecient if the size of θ∗ is polynomial in the size of


θ (and then polynomial in the size of θ′ for a feasible computational task).Otherwise, the strategy is called inecient.

Lemma 35. ([BHM+16, Lemma 9]) Suppose that σ and θ∗ = ω∗µ∗ denea winning strategy for the approximative quiz game protocol. Then we haveθ′ = ω∗ µ∗ σ = θ∗ σ and therefore O′ = O∗.

We observe that a protocol of the exact quiz game gives always riseto a protocol of the approximative quiz game. To this end, let notationsbe as in our description of the exact model and let be given a sequence(uk)k∈M of elements of M and u ∈ M such that (θ(uk))k∈N converges toθ(u). From the continuity of σ we deduce that the sequence (σ(uk))k∈N =((σθ)(uk)

)k∈N converges to σ(u) = (σθ)(u). The continuity of µ∗ implies

now that((µ∗ σ)(uk)

)k∈N converges to (µ∗ σ)(u). Therefore the sequence(

(µ∗ σ)(uk))k∈N is bounded and has a single accumulation point, namely

v∗ = (µ∗ σ)(u). In particular, the player wins the exact game given byu ∈ M if and only if he wins the approximative quiz game given by thesequence (uk)k∈N dened by uk := u, and u ∈M.

Proposition 36. ([BHM+16, Proposition 10]) Let assumptions and nota-tions be that of the approximative quiz game and let u ∈ M. Suppose thatthe player has a winning strategy. Then there exists a nite subset Su of theambient space of N ∗ with the following property: for any sequence (uk)k∈Nin M with (θ(uk))k∈N converging to θ(u), all the accumulation points of((µ∗ σ)(uk)

)k∈N belong to Su.

Corollary 37. ([BHM+16, Corollary 11]) Let assumptions and notationsbe that of the approximative quiz game. Suppose that the player has awinning strategy. Then for any u ∈M, the set

µ∗ σ(v) : v ∈M, θ(v) = θ(u)

is nite.

We can analyze the examples of geometric elimination problems of Sec-tion 5 from the point of view of approximative quiz games. Even more, wecan prove the same exponential lower complexity bounds in Section 5 bymeans of the aproximative protocol (see [BHM+16]).

The approximative protocol we described in this last section is a gener-alization of the exact quiz game described in Section 4. However, we haveto be careful with such a generalization, the exact quiz game of Section 4is a model for objectoriented elimination algorithms, the approximativequiz game is a model for approximative algorithms which are not objectoriented since they work directly with the representation (a sequence ofrepresentations).


6.2 Concluding Remarks

Scientic research in elimination theory has two instances of particular in-terest. One instance is the search of ecient elimination algorithms bymeans of improving data structures and representations of polynomials.The other instance studies the intrinsic complexity of elimination by meansof lower complexity bounds for elimination algorithms. In this thesis we aremainly concerned with the intrinsic complexity, indeed we introduce a noveltechnique to obtain lower complexity bounds. The heart of our novel tech-nique is a special computation model which captures notions like abstractdata type, abstraction function, information hiding and nonfunctional re-quirements (see Sections 3 and 4). In this sense, our model is a softwareengineeringbased computation model and constitutes a new connectionbetween Software Engineering and the theoretical elds of Algebraic Ge-ometry and Computational Complexity Theory.

Our software engineeringbased computation model allows us to givelower complexity bounds for circuitbased elimination algorithms, objectoriented elimination algorithms and approximative elimination algorithms.Such a variety of algorithms and the exponential lower bound we are ableto prove suggests, at least in our model, that elimination has an intrinsicexponential character.

An Alternative Interpretation

Now we describe an alternative interpretation to the computation modelwe have dened in this thesis.

In natural sciences, e.g. Astronomy, a model is a simplied representa-tion of a complex reality like the universe. This simplied representationusually captures only the most important characteristics of a reality whichis full of features, parameters and properties. This view of a model asa simplication of a complex reality can be inverted when we talk aboutpolynomials.

Polynomials are mathematical objects, but in computer science, poly-nomials are dened by means of abstract data type specications. Observethat polynomials in mathematics have several details which are not cap-tured by abstract data types which limit its descriptions to functional prop-erties, e.g., the property of geometrical robustness we have studied in thisthesis is not captured by the abstract data type Poly we dened in Section3.1. In this sense, abstract data types and therefore classes (the underlyingsoftware text) are a simplied representation of a complex reality givenby polynomials in its mathematical environment. Thus, our computationmodel is not a simplication (usual interpretation of a model), even more,our computation model becomes a detailed description of a reality whichoccurs with polynomials and the software text becomes the model. Our


computation model may become meaningful with this interpretation.

Final Comments and Future Work

This thesis is a compilation of some years of research in a classic and antiquesubject in computer science, namely, the questions about complexity. Ourinitial motivation to start this thesis was the desire to understand and makeunderstood the meaning behind a complexity lower bound. At this pointwe believe that from the point of view of Software Engineering, a deepunderstanding of the subject was gained, but there is a long way to walkstill. Thus, we are happy to leave these lines to the reader, who will takethe knowledge frontier we have reached even further.

Andrés Rojas Paredes Joos Heintz


Algoritmos Aproximativos y Conclusión

Algoritmos Aproximativos

En esta sección generalizamos nuestro protocolo de quiz games por medio deinformación de naturaleza aproximativa. Para este propósito, primero se in-troduce una representación de polinomios dados por información aproxima-tiva, i.e., por instancias paramétricas aproximativas. Esta representaciónaproximativa proporciona la motivación para nuestro segundo protocolo,que se llama quiz game aproximativo. Como este protocolo aproximativosiguen las mismas reglas que con el protocolo exacto de la Sección 4, noslimitaremos a las diferencias.

Las respuestas del quizmaster a las preguntas del player son represen-tadas por una función geométricamente robusta σ con dominio de deniciónM. Esta situación se puede ver en la Figura 49.

O∗ M∗θ∗oo

µ∗

O τ // O′

N ∗

ω∗

OO

N

ω

OO

N ′

ω′

OO

M

bb bb

σ

bb

µ

OO

θ

II

µ′

CC

θ′

UU

Figure 49: Quiz game para un algoritmo aproximativo.

El quizmaster elige una sequencia (uk)k∈N enM y un elemento u ∈Mtal que (θ(uk))k∈N converge a θ(u), y oculta esta información al player. Lasrespuestas del quizmaster a las preguntas del player codican la secuen-cia (σ(uk))k∈N, que no es necesariamente convergente. A partir de estasrespuestas el player inere la secuencia

((µ∗ σ)(uk)

)k∈N, que es acotada.

El player gana el juego aproximativo si existe un punto de acumulaciónv∗ de

((µ∗ σ)(uk)

)k∈N en la topología de Euclides con ω∗(v∗) = θ′(u).

El quizmaster verica que las igualdades v′ = µ′(u) y ω∗(v∗) = ω′(v′) secumplen.

Podemos analizar los ejemplos de eliminación geométrica de la Sección5 desde el punto de vista del quiz game aproximativo. Más aún, usando elprotocolo aproximativo se pueden probar las mismas cotas exponencialesque hemos discutido en la Sección 5, ver [BHM+16] donde estas cotas sondemostradas como casos particulares del quiz game aproximativo.


El protocolo aproximativo que describimos en esta última sección es unageneralización del quiz game exacto descrito en la Sección 4. Sin embargo,debemos tener cuidado con esta generalización, el quiz game exacto de Sec-ción 4 es un modelo para algoritmos de eliminación dentro del paradigmaorientado a objetos, el quiz game aproximativo es un modelo para algorit-mos aproximativos que no pertenecen al paradigma orientado a objetos yaque trabajan directamente con la representación (una secuencia de repre-sentaciones que se aproximan a una representación exacta).

Observaciones nales

La investigación cientíca en teoría de la eliminación tiene dos instanciasde interés particular. Una instancia es la búsqueda de algoritmos de elimi-nación ecientes mediante mejoras en las estructuras de datos y representa-ciones de polinomios. La otra instancia, estudia la complejidad intrínsecade eliminación por medio de cotas inferiores de complejidad para algoritmosde eliminación. En esta tesis nos ocupamos principalmente de la comple-jidad intrínseca, en efecto, introducimos una técnica para obtener cotasinferiores de complejidad. El corazón de nuestra técnica es un modelo decómputo especial que captura las nociones de tipo abstracto de datos, lafunción de abstracción, el ocultamiento de la información y los requerimien-tos nofuncionales (ver Secciones 3 y 4). En este sentido, nuestro modeloconstituye una conexión entre la Ingeniería de Software y los campos teóri-cos de Geometría Algebraica y Teoría de la Complejidad Computacional.

Nuestro modelo de cómputo considera polinomios como tipos abstrac-tos de datos que se implementan en términos de circuitos aritméticos. Paradescribir los tipos abstractos de datos y sus implementaciones utilizamos ellenguaje de B. Meyer en [Mey97], que es nuestra referencia para utilizar laterminología de Ingeniería de Software. Nuestro modelo de cómputo cap-tura dos niveles de abstracción: polinomios y circuitos, pero sólo con estascaracterísticas nuestro modelo no sería diferente de las especicaciones for-males en Ingeniería de Software. Consideramos la robustez como atributode calidad clave de los algoritmos en general y de los algoritmos de elimi-nación en particular. Hemos modelado la noción de robustez por medio deuna propiedad matemática llamada robustez geométrica (ver Sección 3.3).Esta propiedad matemática indica que nuestro modelo de cómputo es denaturaleza geométrica donde las estructuras de representación son subcon-juntos de espacios anes y los tipos abstractos de datos son subconjuntosde anillos de polinomios. Esta característica matemática puede hacer quenuestra investigación termine en una formulación matemática y orientadaa especialistas. Para evitar esta situación, que es también un objetivo deeste trabajo, hemos denido nuestro modelo paso a paso indicando quéparte matemática corresponde a qué concepto de Ingeniería de Software.


El resultado de este procedimiento es un modelo matemático que tiene unaclara interpretación en la informática. Este modelo permite obtener resul-tados matemáticos (vinculados a la dimensión de los espacios anes) queson traducidos al contexto original de la informática como cotas inferioresde complejidad.

A partir de la Sección 3 podemos armar que existe una familia de poli-nomios de eliminación que no admite un algoritmo eciente de eliminaciónbasado en circuitos aritméticos que sean robustos. En otras palabras, lacomplejidad de un algoritmo de eliminación que es capturado por nuestromodelo de cómputo tiene necesariamente complejidad exponencial, este esel principal contenido de [HKRP13b]. El resultado principal obtenido enesta tesis se reere al caso en que los circuitos aritméticos se sustituyen poruna estructura de datos diferente. En este caso, todos los algoritmos queutilizan la antigua estructura de datos se volverían inútiles porque la in-terfaz de la nueva estructura de datos puede cambiar drásticamente. Paraevitar esta situación se puede aplicar ocultamiento de la información, i.e.,la técnica para ocultar las partes de un software que pueden cambiar. Estatécnica consiste en encapsular la estructura de datos que se va a cambiarcon la interfaz del correspondiente tipo abstracto de datos. El resultado esun algoritmo que sólo se dene en términos de las funciones proporcionadaspor el tipo abstracto de datos, y la representación permanece encapsulada.Cualquier cambio en esta parte del algoritmo sigue siendo invisible.

Hemos modelado la noción de ocultamiento de la información con unprotocolo interactivo que llamamos quiz games. Este protocolo simula alprogramador que construye un algoritmo usando solamente las funcionesproporcionadas por el tipo abstracto de datos. El resultado es que capta-mos todos los algoritmos construidos de esta manera, i.e., en el paradigmaorientado a objetos. Nuestro modelo incorpora de nuevo la noción de ro-bustez como un requerimiento nofuncional clave y deseable de los algo-ritmos. Nuestro modelo de cómputo captura ahora algoritmos orientadosa objetos que son robustos, permite demostrar que existen ciertas familiasde problemas de eliminación que admiten cotas inferiores de complejidadexponenciales en este modelo. En otras palabras, en nuestro modelo decómputo no hay un algoritmo orientado a objetos que sea robusto y quepueda resolver ecientemente problemas de eliminación como una tareageneral.

Nuestro modelo de cómputo basado en Ingeniería de Software nos per-mite dar cotas inferiores de complejidad para algoritmos de eliminaciónbasados en circuitos aritméticos, algoritmos de eliminación orientados aobjetos y algoritmos de eliminación aproximativos. Tal variedad de al-goritmos y la cota inferior exponencial que podemos obtener sugiere, almenos en nuestro modelo, que la eliminación tiene un carácter exponencialintrínseco.


Esta tesis es una compilación de algunos años de investigación en untema clásico y antiguo en informática: las preguntas sobre la complejidad.Nuestra motivación principal al momento de iniciar esta tesis fue el deseode entender y hacer entender el signicado detrás de una cota inferior decomplejidad. En este sentido, creemos que desde el punto de vista de laIngeniería de Software se obtuvo una comprensión profunda del tema, peroaún queda un largo camino por recorrer. Por lo tanto, estamos contentosde dejar estas líneas al lector, que llevará la frontera del conocimiento quehemos alcanzado aún más lejos.


References

[AHM+98] M. Aldaz, J. Heintz, G. Matera, J. L. Montaña, and L. M.Pardo. Combinatorial Hardness Proofs for Polynomial Evalu-ation. In L. Brim, J. Gruska, and J. Zlatuska, editors, Mathe-matical Foundations of Computer Science 1998, volume 1450of Lecture Notes in Computer Science, pages 167175. SpringerBerlin Heidelberg, 1998.

[AHU74] A. Aho, J. Hopcroft, and J. Ullman. The Design and Analysisof Computer Algorithms. Addison-Wesley series in computerscience and information processing. Addison-Wesley Pub. Co.,1974.

[AHU83] A. V. Aho, J. E. Hopcroft, and J. D. Ullman. Data Structuresand Algorithms. AddisonWesley Publishing Company, 1stedition, 1983.

[Ald84] A. Alder. Grenzrang und Grenzkomplexität aus algebraischerund topologischer Sicht. PhD thesis, Universität Zürich, 1984.

[BCK98] L. Bass, P. Clements, and R. Kazman. Software Architecturein Practice. Addison-Wesley Longman Publishing Co., Inc.,Boston, MA, USA, 1998.

[BCS97] T. Bürgisser, M. Clausen, and A. Shokrollahi. Algebraic Com-plexity Theory, volume 315 of Grundlehren der mathematis-chen Wissenschaften. Springer Berlin Heidelberg, 1997.

[BGHM01] B. Bank, M. Giusti, J. Heintz, and G. M. Mbakop. PolarVarieties and Ecient Real Elimination. MATH. Z, pages115144, 2001.

[BHM+16] B. Bank, J. Heintz, G. Matera, J. L. Montaña, L. M. Pardo,and A. Rojas Paredes. Quiz Games as a Model for InformationHiding. Journal of Complexity, 34:1 29, 2016.

[Bor75] A. Borodin. The Computational Complexity of Algebraic andNumeric Problems. Completar Publisher, 1975.

[Bör89] E. Börger. Computability, Complexity, Logic. Studies in Logicand the Foundations of Mathematics. Elsevier Science, 1989.

[BP93] J. Brookshear and E. Peake. Teoría de la Computación:Lenguajes Formales, Autómatas y Complejidad. Addison-Wesley Iberoamericana Espana, S.A., 1993.


[BRJ99] G. Booch, J. E. Rumbaugh, and I. Jacobson. The Uni-ed Modeling Language User Guide. J. Database Manag.,10(4):5152, 1999.

[Bro87] J. F. P. Brooks. No Silver Bullet, Essence and Accidents ofSoftware Engineering. Computer, 20(4):1019, April 1987.

[Bru98] N. Bruno. Esquemas de Compilación de Circuitos AritméticosUniformes Descriptos por medio de Funciones Generatrices.Master's thesis, Facultad de Matemática, Astronomía y Física,Universidad Nacional de Córdoba, Córdoba, 1998.

[Bun12] M. Bun. The Geometric Complexity Theory Ap-proach to Algebraic Complexity. Manuscript atwww.math.washington.edu, 2012.

[CGH+01] D. Castro, M. Giusti, J. Heintz, G. Matera, and L. M. Pardo.Data Structures and Polynomial Equation Solving. In An-nales JAIIO 30, WAIT 2001 (Workshop Argentina Inform.Teórica.), pages 4360, Buenos Aires, Argentina, 2001.

[CGH+03] D. Castro, M. Giusti, J. Heintz, G. Matera, and L. M. Pardo.The Hardness of Polynomial Equation Solving. In Foundationsof Computational Mathematics, pages 174, 2003.

[CGL12] S. Chaudhuri, S. Gulwani, and R. Lublinerman. Continuityand Robustness of Programs. Commun. ACM, 55(8):107115,August 2012.

[Cho10] N. Chomsky. Estructuras Sintácticas. Siglo XXI editores,2010.

[CLRS09] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein.Introduction to Algorithms. The MIT Press, 3rd edition, 2009.

[CNYM12] L. Chung, B. Nixon, E. Yu, and J. Mylopoulos. Non-Functional Requirements in Software Engineering. Interna-tional Series in Software Engineering. Springer US, 2012.

[Con65] S. D. Conte. Elementary Numerical Analysis: an AlgorithmicApproach. McGrawHill, New York, 1965.

[CPHM01] D. Castro, L. M. Pardo, K. Hägele, and J. E. Morais. Kro-necker's and Newton's Approaches to Solving: A First Com-parison. Journal of Complexity, 17(1):212 303, 2001.


[DE10] A. Dickenstein and I. Z. Emiris. Solving Polynomial Equa-tions: Foundations, Algorithms, and Applications. SpringerPublishing Company, Incorporated, 1st edition, 2010.

[DSW94] M. D. Davis, R. Sigal, and E. J. Weyuker. Computability,Complexity, and Languages (2Nd Ed.): Fundamentals of The-oretical Computer Science. Academic Press Professional, Inc.,San Diego, CA, USA, 1994.

[EF05] H. Ebbinghaus and J. Flum. Finite Model Theory. SpringerMonographs in Mathematics. Springer Berlin Heidelberg,2005.

[Eis95] D. Eisenbud. Commutative Algebra with a View Toward Alge-braic Geometry, volume 150 of Grad. Texts in Math. Springer,New York, 1995.

[FGLM93] J. C. Faugère, P. Gianni, D. Lazard, and T. Mora. EcientComputation of Zero-dimensional Gröbner Bases by Changeof Ordering. Journal of Symbolic Computation, 16(4):329344,October 1993.

[FIK86] T. Freeman, G. Imirzian, and E. Kaltofen. A System for Ma-nipulating Polynomials Given by Straight-line Programs. InProceedings of the Fifth ACM Symposium on Symbolic and Al-gebraic Computation, SYMSAC '86, pages 169175, New York,NY, USA, 1986. ACM.

[Fla98] G. Flake. The Computational Beauty of Nature: ComputerExplorations of Fractals, Chaos, Complex Systems, and Adap-tation. A Bradford book. Cambridge, Massachusetts, 1998.

[GH01] M. Giusti and J. Heintz. Kronecker'Smart, Little Black Boxes,pages 69104. Number 284 in London Mathematical SocietyLecture Notes. Cambridge University Press, 2001.

[GHH+97] M. Giusti, J. Heintz, K. Hägele, J. Morais, L. Pardo, andJ. Montaña. Lower Bounds for Diophantine Approximations.Journal of Pure and Applied Algebra, 117118:277317, 1997.

[GHJV95] E. Gamma, R. Helm, R. Johnson, and J. Vlissides. De-sign Patterns: Elements of Reusable Object-Oriented Software.Addison-Wesley Longman Publishing Co., Inc., Boston, MA,USA, 1995.


[GHM+98] M. Giusti, J. Heintz, J. Morais, J. Morgenstem, and L. Pardo.Straight-Line Programs in Geometric Elimination Theory.Journal of Pure and Applied Algebra, 124(1):101146, 1998.

[GHMP95] M. Giusti, J. Heintz, J. E. Morais, and L. M. Pardo. WhenPolynomial Equation Systems can be "Solved" Fast? InProceedings of the 11th International Symposium on AppliedAlgebra, Algebraic Algorithms and Error-Correcting Codes,AAECC-11, pages 205231, London, UK, UK, 1995. Springer-Verlag.

[GHMS11] N. Giménez, J. Heintz, G. Matera, and P. Solernó. LowerComplexity Bounds for Interpolation Algorithms. Journal ofComplexity, 27(2):151 187, 2011.

[GKW03] J. Grabmeier, E. Kaltofen, and V. Weispfenning, editors.Computer Algebra Handbook : Foundations, Applications, Sys-tems. Springer, New York, 2003.

[GLS01] M. Giusti, G. Lecerf, and B. Salvy. A Gröbner Free Alterna-tive for Polynomial System Solving. Journal of Complexity,17(1):154 211, 2001.

[GMR85] S. Goldwasser, S. Micali, and C. Racko. The KnowledgeComplexity of Interactive Proof-systems. In Proceedings ofthe Seventeenth Annual ACM Symposium on Theory of Com-puting, STOC '85, pages 291304, New York, NY, USA, 1985.ACM.

[Gri06] R. Grimson. Quantier Elimination in Algebraically ClosedFields. Master's thesis, Hasselt University, Belgium, 2006.

[GY05] J. L. Gross and J. Yellen. Graph Theory and Its Applications,Second Edition (Discrete Mathematics and Its Applications).Chapman & Hall/CRC, 2005.

[HDB96] M. Hagan, H. Demuth, and M. Beale. Neural Network Design.PWS Publishing Company, Boston, MA, 1996.

[Hei83] J. Heintz. Denability and Fast Quantier Elimination inAlgebraically Closed Fields. Theoretical Computer Science,24(3):239 277, 1983.

[HK04] J. Heintz and B. Kuijpers. Constraint Databases, Data Struc-tures and Ecient Query Evaluation. In B. Kuijpers and


P. Revesz, editors, Constraint Databases, volume 3074 of Lec-ture Notes in Computer Science, pages 124. Springer BerlinHeidelberg, 2004.

[HKP91] J. Hertz, A. Krogh, and R. Palmer. Introduction to the The-ory of Neural Computation. AddisonWesley, Reading, Mas-sachusetts, 1991.

[HKP99] S. Haykin, A. Krogh, and R. Palmer. Neural Networks, a Com-prehensive Foundation. Prentice Hall, Upper Saddle River, NJ,second edition, 1999.

[HKRP13a] J. Heintz, B. Kuijpers, and A. Rojas Paredes. On the Intrin-sic Complexity of Elimination Problems in Eective AlgebraicGeometry. In J. L. Montaña and L. M. Pardo, editors, Recentadvances in real complexity and computation, volume 604 ofContemp. Math., pages 129150, Providence, RI, 2013. Amer.Math. Soc.

[HKRP13b] J. Heintz, B. Kuijpers, and A. Rojas Paredes. Software En-gineering and Complexity in Eective Algebraic Geometry.Journal of Complexity, 29(1):92138, February 2013.

[HM93] J. Heintz and J. Morgenstern. On the Intrinsic Complexityof Elimination Theory. Journal of Complexity, 9(4):471498,December 1993.

[HMW01] J. Heintz, G. Matera, and A. Waissbein. On the TimeSpaceComplexity of Geometric Elimination Procedures. Applica-ble Algebra in Engineering, Communication and Computing,11(4):239296, 2001.

[Hoa72] C. Hoare. Proof of Correctness of Data Representations. ActaInformatica, 1(4):271281, 1972.

[HS81] J. Heintz and M. Sieveking. Absolute Primality of Polynomialsis Decidable in Random Polynomial Time in the Number ofVariables. In Proceedings of the 8th Colloquium on Automata,Languages and Programming, pages 1628, London, UK, UK,1981. Springer-Verlag.

[Ive73] B. Iversen. Generic Local Structure of the Morphisms in Com-mutative Algebra, volume 310 of Lecture notes in mathematics.Springer-Verlag, 1973.


[JNM+12] I. Jacobson, P.-W. Ng, P. McMahon, I. Spence, and S. Lidman.The Essence of Software Engineering: the Semat Kernel. CSICommunications, page 7, 2012.

[Kal88] E. Kaltofen. Greatest Common Divisors of Polynomials Givenby Straightline Programs. J. ACM, 35(1):231264, January1988.

[KL80] R. M. Karp and R. J. Lipton. Some Connections BetweenNonuniform and Uniform Complexity Classes. In Proceedingsof the Twelfth Annual ACM Symposium on Theory of Com-puting, STOC '80, pages 302309, New York, NY, USA, 1980.ACM.

[Kol88] J. Kollar. Sharp Eective Nullstellensatz. Journal of theAmerican Mathematical Society, 1(4):963975, 1988.

[Kun85] E. Kunz. Introduction to Commutative Algebra and AlgebraicGeometry. Birkhäuser, Boston, 1985.

[Lec] G. Lecerf. Geomsolvex: Implementation of the KroneckerPolynomial Solver for a Reduced Regular Sequence. www.

mathemagix.org. Version: 0.1.

[LG00] B. Liskov and J. Guttag. Program Development in Java: Ab-straction, Specication, and Object-Oriented Design. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA, 1stedition, 2000.

[Lic90] T. M. Lickteig. On Semialgebraic Decision Complexity. Tech-nical Report TR-90-052, Int. Comput. Sci. Inst., Berkeley,1990.

[LW01] L. Lehmann and A. Waissbein. Wavelets and SemiAlgebraicSets. In Annales JAIIO 30, WAIT2001 (Workshop ArgentinaInform. Teórica.), pages 139155, Buenos Aires, Argentina,2001.

[Mey97] B. Meyer. ObjectOriented Software Construction. Prentice-Hall, Inc., Upper Saddle River, NJ, USA, 2 edition, 1997.

[MSM98] J. E. Morais San Miguel. Resolución Ecaz de Sistemasde Ecuaciones Polinomiales. PhD thesis, Universidad deCantabria, España, 1998.

[Mum88] D. Mumford. The Red Book of Varieties and Schemes, vol-ume 1358 of Lecture Notes in Math. Springer, New York, 1stedition, 1988.


www.mathemagix.org

www.mathemagix.org

[Oca12] H. Ocar. Descriptive Complexity, a Survey. Manuscript at theUniversity of Buenos Aires, May 2012.

[Pan97] V. Y. Pan. Solving a Polynomial Equation: Some History andRecent Progress. SIAM Rev., 39(2):187220, 1997.

[Par72] D. L. Parnas. On the Criteria to Be Used in DecomposingSystems into Modules. Commun. ACM, 15(12):10531058,December 1972.

[Par95] L. M. Pardo. How Lower and Upper Complexity Bounds Meetin Elimination Theory. In Proceedings of the 11th Interna-tional Symposium on Applied Algebra, Algebraic Algorithmsand Error-Correcting Codes, AAECC-11, pages 3369, Lon-don, UK, UK, 1995. Springer-Verlag.

[Pud95] S. I. Puddu. Un Algoritmo Efectivo para la Eliminación deCuanticadores. PhD thesis, Universidad de Buenos Aires,Argentina, 1995.

[Ral70] A. Ralston. Introducción al Análisis Numérico. Limusa-Wiley,México, 1970.

[RP11] A. Rojas Paredes. Complexity as Quality Attribute in Soft-ware Design. Master's thesis, Facultad de Ciencias Exactas yNaturales, Universidad de Buenos Aires, Pabellón 1, CiudadUniversitaria, 2011.

[Sav98] J. Savage. Models of Computation: Exploring the Power ofComputing. Addison Wesley, 1998.

[Sha94] I. R. Shafarevich. Basic Algebraic Geometry: Varieties in Pro-jective Space. Springer, Berlin Heidelberg New York, 1994.

[Som99] M. Sombra. A Sparse Eective Nullstellensatz. Adv. Appl.Math., 22(2):271295, February 1999.

[SS95] M. Shub and S. Smale. On the Intractability of Hilbert's Null-stellensatz and an Algebraic Version of NP6=P? Duke Math.J., 81(1):4754, 1995.

[Sto77] L. J. Stockmeyer. The Polynomial-Time Hierarchy. Theoreti-cal Computer Science, 3(1):1 22, 1977.

[SUR] SURFER. Visualization of Algebraic Surfaces by the Math-ematisches Forschungsinstitut Oberwolfach. imaginary.org/program/surfer. Version: 1.5.0.


imaginary.org/program/surfer

imaginary.org/program/surfer

[Ter] Turbo Evaluation and Rapid Algorithms. http://www.dm.

uba.ar/tera/.

[Tur36] A. M. Turing. On Computable Numbers, with an Applica-tion to the Entscheidungsproblem. Proceedings of the LondonMathematical Society, 2(42):230265, 1936.

[Veo] VeoVeo guessing game. https://es.wikipedia.org/wiki/Veo_veo.


http://www.dm.uba.ar/tera/

http://www.dm.uba.ar/tera/

https://es.wikipedia.org/wiki/Veo_veo

https://es.wikipedia.org/wiki/Veo_veo

A The Identity Function which Change

the Representation

In this section we give a novel implementation of the well known notion ofidentity function. Our implementation belongs to the paradigm of objectoriented programming and it allows to change the choice of representationof a given class without direct access to this choice of representation.

Let TREE be an abstract data type of binary trees with query func-tions (observers) root(), left(), right() and isNil?(), and creator functions(constructors) bin() and nil(). We propose the following denition for theidentity function of binary trees:

idTREE(X) =

nil() if isNil? (X)bin(root(X), idTREE(left(X)), idTREE(right(X))) otherwise

(32)

Function idTREE in (32) admits an implementation such that at a con-crete level a transformation of the representation of binary trees is carriedout, whereas at an abstract level the implementation is the identity func-tion of binary trees. In order to illustrate this hidden transformation we aregoing to consider two dierent classes implementing the abstract data typeof binary trees. In the following paragraph we write the implementationin verbatim font in order to stress the dierence with abstract data typeexpressions which we write in cursive font. The example we are going toshow was implemented in Java programming language.

Let E be a variable denoting any class. Let Tree<E> be a class imple-menting the abstract data type of binary trees. Let Tree1<E> and Tree2<E>be subclasses of class Tree<E> with the following property: the choice ofrepresentation of Tree1<E> is given by arrays and the choice of represen-tation of Tree2<E> is given by nested nodes. Let root, left, right andisNil be routines in the class Tree<E> implementing the correspondingquery functions (observers) in the abstract data type specication. Thenour implementation is as follows:

Tree<E> id(Tree<E> t)if(t.isNil()) return new Tree2<E>();

else return new Tree2<E>(t.root(),

(Tree2<E>) id(t.left()),

(Tree2<E>) id(t.right()) );

(33)

Notice that the eective transformation of the representation is carriedout when the input parameter t is an instance of the class Tree1<E> andthe output is always an instance of the other class Tree2<E>. Observe


that the change of the representation is a consequence of the combinationof observers applied to an input instance of Tree1<E> and constructors ofTree2<E> applied to generate the output. We may call implementation 33an object-oriented implementation of function idTREE.


B Tools from Algebraic Geometry

In this section, we use freely standard notions and notations from commu-tative algebra and algebraic geometry. These can be found for example in[Eis95], [Kun85], [Mum88] and [Sha94].

B.1 Notions and Notation from Algebraic Geometry

Let k be a xed algebraically closed eld of characteristic zero. For any n ∈N, we denote by Cn(k) the ndimensional ane space kn equipped with itsZariski topology. For k = C, we consider the complex ndimensional anespace Cn := Cn(C), equipped with its respective Zariski and Euclideantopologies.

LetX1, . . . , Xn be indeterminates over k and letX := (X1, . . . , Xn). Wedenote by k[X] := k[X1, . . . , Xn] the ring of polynomials in the variablesX with coecients in k.

Let V be a closed ane subvariety of Cn(k). We denote by

I(V ) := f ∈ k[X] : f(x) = 0 for any x ∈ V

the ideal of denition of V in k[X] and by

k[V ] := φ : V → k : ∃ f ∈ k[X] with φ(x) = f(x) for any x ∈ V

its coordinate ring. The elements of k[V ] are called coordinate functions ofV . Observe that k[V ] is isomorphic to the quotient kalgebra k[X]/I(V ).If V is irreducible, then k[V ] has no zero divisors, and we denote by k(V )the eld formed by the rational functions of V with maximal domain (k(V )is called the rational function eld of V ). Observe that k(V ) is isomorphicto the fraction eld of the integral domain k[V ].

Let V and W be closed ane subsets of Cn(k) and Cm(k), respectively,and let Φ : V → W be a (total) map. We call Φ a morphism from theane variety V toW if there exist polynomials f1, . . . , fm ∈ k[X] such thatΦ(x) = (f1(x), . . . , fm(x)) holds for any x ∈ V .

Let V be irreducible, let U be a nonempty Zariski open subset of V andlet Φ : V 99K W be a partial map with domain U . Let Φ1, . . . ,Φm be thecomponents of Φ. We call Φ a rational map from V to W if Φ1, . . . ,Φm arethe restrictions to U of suitable rational functions of V . Observe that ourdenition of a rational map diers slightly from the usual one in algebraicgeometry, since we do not require that the domain U of Φ is maximal.Hence in the case m := 1 our concepts of rational function and rationalmap do not coincide. However we will not stick on this point and simplyspeak about rational functions when m = 1.

Let M be a subset of some ane space Cn, a basic fact we use inthis thesis is that ifM is constructible (see Denition 9), then its Zariski


closureM is equal to its Euclidean closure (see, e.g. [Mum88, Chapter I,10, Corollary 1]).

B.2 Geometrically Robust Constructible Maps

Let k be a xed algebraically closed eld of characteristic zero. For anym ∈ N, we denote by Cm(k) the mdimensional ane space km equippedwith its Zariski topology.

LetM be a constructible subset of a suitable ane space over k and letΦ :M→ Cm(k) be a total constructible map with components Φ1, . . . ,Φm.

If Φ is a geometrically robust constructible map, we callM the domainof denition of Φ. The following statements characterize the unique prop-erties of geometrically robust constructible maps which are relevant in thisthesis.

Theorem 38.

(i) The restriction of a geometrically robust constructible map to a con-structible subset of its domain is geometrically robust.

(ii) Compositions and Cartesian products of geometrically robust con-structible maps are geometrically robust.

(iii) A geometrically robust constructible map dened on a normal (e.g.,smooth) variety is a polynomial map.

(iv) Polynomial maps are geometrically robust and constructible and thegeometrically robust constructible functions of a constructible domainof denition form a kalgebra.

For a proof of the statements (i) and (iii) we refer to [GHMS11, The-orem 14 and Corollary 12], respectively. The statements (ii) and (iv) areimmediate consequences of [HKRP13b, Denition 6].

With some extra eort one can also show that geometrically robustconstructible maps are continuous with respect to the Zariski topologies oftheir domain and range spaces. Furthermore, we have the following result(for a proof see [HKRP13b, Theorem 4]).

Theorem 39. LetM be a constructible subset of Cn and let Φ :M→ Cm

be a constructible total map. Then Φ is geometrically robust if and only ifΦ is continuous with respect to the Euclidean topologies ofM and Cn.

Theorem 39 gives a topological characterization of the notion of geo-metrically robust constructible maps over C. This notion represents thereal motivation of the algebraic denition of geometrically robust maps in[BHM+16, Denition 4], both from a geometric as well as from an algorith-mic point of view.


C Polynomials which are Easy to Evaluate

Let X and T be indeterminates. Let D := 2r+1 − 1 for some r ≥ 0. Thepolynomial

(TD − 1)∑

0≤k≤D

T kXk (34)

is a polynomial which is easy to evaluate, namely, it is evaluable by anarithmetic circuit of size l of order O(log(D)). This bound follows fromLemmas 40 and 41 below.

Observe that we can decompose polynomial (34) in the following twopolynomials:

G∗ := (TD − 1) and F ∗ :=∑

0≤k≤D

T kXk.

Lemma 40. The polynomial

G∗ := (TD − 1)

can be evaluated by an arithmetic circuit of size O(log(D)).

Proof. Observe that G∗ can be rewritten as

G∗ = (TD − 1) = (T∑rj=0 2j − 1) (35)

Since D := 2r+1 − 1, the following geometric sum holds

r∑j=0

2j = 2r+1 − 1. (36)

Thus, from (35) the polynomial G∗ can be evaluated with an arithmeticcircuit of O(r) nodes. This bound is easy to see by means of the followingequality:

T∑rj=0 2j = T 20 .T 21 .T 22 . . . T 2r︸︷︷︸

r multiplications

where r multiplications can be carried out with the following algorithm

T 2j = T 2j−1

.T 2j−1

for 1 ≤ j ≤ r.

Figure 50 below illustrates an arithmetic circuit evaluating G∗. Observethat this circuit applies r+ 1 operations. Thus, G∗ can be evaluated by anarithmetic circuit of size O(r) = O(log(D)).


TT 20

input

1

∗T 21

∗T 22

...

∗T 2r−1

∗T 2r

−

output

rmultiplications

Figure 50: Arithmetic circuit evaluating G∗.

Lemma 41. The polynomial

F ∗ :=∑

0≤k≤D

T kXk

can be evaluated by an arithmetic circuit of size O(log(D)).

Proof. Since D := 2r+1 − 1, observe that F ∗ can be rewritten as

F ∗ =2r+1−1∑k=0

(TX)k =r∏l=0

(1 + (TX)2l). (37)

Figure 51 below illustrates an arithmetic circuit evaluating F ∗. Observethat this circuit applies 3r + 2 operations. Thus, F ∗ can be evaluated byan arithmetic circuit of size O(r) = O(log(D)).


T

input

X

input

1

+

+

...

+

+

∗

...

∗

∗ouput

∗(TX)20

∗(TX)21

∗(TX)22

...

∗(TX)2r−1

∗(TX)2r

r+1multiplications

r + 1 sums

rmultiplications

Figure 51: Arithmetic circuit evaluating F ∗.


'Un modelo de cómputo basado en ocultamiento de la ...

Documents

Transcript of 'Un modelo de cómputo basado en ocultamiento de la ...