Quotient Types in Type Theory

Total Page:16

File Type:pdf, Size:1020Kb

Quotient Types in Type Theory Quotient Types in Type Theory Nuo Li, BSc. Thesis submitted to the University of Nottingham for the degree of Doctor of Philosophy September 2014 Abstract Martin-Löf’s intuitionistic type theory (Type Theory) is a formal system that serves not only as a foundation of constructive mathematics but also as a depen- dently typed programming language. Dependent types are types that depend on values of other types. Type Theory is based on the Curry-Howard isomorphism which relates computer programs with mathematical proofs so that we can do computer-aided formal reasoning and write certified programs in programming lan- guages like Agda, Epigram etc. Martin Löf proposed two variants of Type Theory which are differentiated by the treatment of equality. In Intensional Type Theory, propositional equality defined by identity types does not imply definitional equal- ity, and type checking is decidable. In Extensional Type Theory, propositional equality is identified with definitional equality which makes type checking unde- cidable. Because of the good computational properties, Intensional Type Theory is more popular, however it lacks some important extensional concepts such as functional extensionality and quotient types. This thesis is about quotient types. A quotient type is a new type whose equality is redefined by a given equivalence relation. However, in the usual formulation of Intensional Type Theory, there is no type former to create a quotient. We also lose canonicity if we add quotient types into Intensional Type Theory as axioms. In this thesis, we first investigate the expected syntax of quotient types and explain it with categorical notions. For quotients which can be represented as a setoid as well as defined as a set without a quotient type former, we propose to define an algebraic structure of quotients called definable quotients. It relates the setoid interpretation and the set definition via a normalisation function which returns a normal form (canonical choice) for each equivalence class. It can be seen as a simulation of quotient types and it helps theorem proving because we can benefit from both representations. However this approach cannot be used for all quotients. It seems that we cannot define a normalisation function for some quotients in Type Theory, e.g. Cauchy reals and finite multisets. Quotient types are indeed essential for formalisation of mathematics and reasoning of programs. Then we consider some models of Type Theory where types are interpreted as structured objects such as setoids, groupoids or weak !-groupoids. In these models iii equalities are internalised into types which means that it is possible to redefine equalities. We present an implementation of Altenkirch’s [3] setoid model and show that quotient types can be defined within this model. We also describe a new extension of Martin-Löf type theory called Homotopy Type Theory where types are interpreted as weak !-groupoids. It can be seen as a generalisation of the groupoid model which makes extensional concepts including quotient types available. We also introduce a syntactic encoding of weak !-groupoids which can be seen as a first step towards building a weak !-groupoids model in Intensional Type Theory. All of these implementations were performed in the dependently typed programming language Agda which is based on intensional Martin-Löf type theory. iv Acknowledgements The first person I would like to thank is my supervisor Thorsten Altenkirch. He offered me a great internship opportunity about encoding numbers in Agda, which later developed into my PhD project. He was always patient in answering questions and taught me a lot about research. I would also like to thank him for his guidance and feedback on this thesis. I would also thank my second supervisor Thomas Anberrée who introduced me to functional programming and gave me precious advice on my project. I would also like to thank Venanzio Capretta who examined my first and second year reports and provided me with helpful feedback. I would like to thank Ambrus Kaposi and Nicolai Kraus for their great help in writ- ing my thesis and comments on my drafts, and correcting my grammatical errors for the final version. My friends Nicolai Kraus, Ambrus Kaposi, Christian Sattler, Paolo Capriotti, Florent Balestrieri, Gabe Dijkstra, Ivan Perez, Neil Sculthorpe and all the other PhD students in our lab helped me a lot by either teaching me mathematics, discussing research topics or playing badminton to exercise our bod- ies. The Functional Programming Lab is like a lively family and I really enjoyed the time here. I would like to thank everyone here. Without their kind help, the thesis would not have been finished. I would also like to thank the organizers and other participants of the special year on Homotopy Type Theory at the Institute for Advanced Study where we had many interesting discussions some of which were related to parts of this work, especially Guillaume Brunerie whose proposal made it possible. I would also like to thank F. Nordvall Forsberg with whom we had important discussions related to our work. I would also like to thank my parents and other family members. During the years in Nottingham, my mother Guangfei Lv and my father Youyuan Li were always very supportive of me, even though I was living far from them. They talked to me a lot and sent my favourite foods to me many times. My aunt Guangshu Lv who is living in Germany also helped me a lot. She gave me many advice and has sent mails to me. Without their support I would have never achieved my goals. v Finally, I would like to thank the School of Computer Science and the International Office at the University of Nottingham who financially supported this project by providing a scholarship. vi Contents 1 Introduction1 1.1 Quotient types.............................2 1.2 Structure of the thesis.........................6 2 Type Theory9 2.1 A brief history of Type Theory.................... 10 2.2 The formal system of Type Theory.................. 15 2.3 An implementation of Type Theory: Agda.............. 20 2.4 Extensional concepts.......................... 26 2.5 An Intensional Type Theory with Prop ............... 31 2.6 Homotopy Type Theory........................ 32 2.7 Summary................................ 37 3 Quotient Types 39 3.1 Quotients in Type Theory....................... 39 3.2 Quotients are coequalizers....................... 45 3.3 Quotients as an adjunction....................... 48 3.4 Quotients in Homotopy Type Theory................. 51 3.5 Related work.............................. 59 3.6 Summary................................ 63 4 Definable Quotients 65 4.1 Algebraic structures of quotients.................... 66 4.2 Integers................................. 70 4.3 Rational numbers............................ 73 4.4 The application of definable quotients................. 79 4.5 Related work.............................. 85 4.6 Summary................................ 86 5 Undefinable Quotients 89 5.1 Definability via normalisation..................... 89 vii Contents viii 5.2 Real numbers as Cauchy sequences.................. 91 5.3 R0= ∼ is undefinable via normalisation................ 93 5.4 Other examples............................. 100 5.5 Related work.............................. 104 5.6 Summary................................ 104 6 The Setoid Model 107 6.1 Introduction............................... 108 6.2 Metatheory............................... 109 6.3 Categories with families........................ 114 6.4 Related work.............................. 124 6.5 Summary................................ 125 7 Syntactic !-groupoids 127 7.1 Syntax of weak !-groupoids...................... 129 7.2 Some Important Derivable Constructions............... 136 7.3 Semantics................................ 147 7.4 Related work.............................. 151 7.5 Summary................................ 151 8 Conclusion and Future Work 153 A Definable quotient structures 157 A.1 Rational numbers............................ 171 B Category with families of setoids 175 B.1 Metatheory............................... 175 B.2 Categories with families........................ 177 C syntactic weak !-groupoids 193 C.1 Syntax of T∞−groupoid .......................... 193 C.2 Some Important Derivable Constructions............... 205 C.3 Sematics................................. 222 Bibliography 225 Chapter 1 Introduction Martin-Löf type theory (or just Type Theory) is a type theory which serves as a foundation of constructive mathematics and is also a dependently typed pro- gramming language. Different from other foundations like set theory, it is not based on predicate logic but internalises the BHK interpretation of intuitionistic logic through the Curry-Howard isomorphism. It identifies propositions with types such that proofs of a proposition become terms of the corresponding type. Viewed as a programming language, this means that we can express a specification as a type, and a program of that type will satisfy the specification. Moreover, one can write programs and reason about them in the same language resulting in certified programs. Implementations of Type Theory include NuPRL, LEGO, Coq, Agda, Epigram, Pi-Sigma. Viewed as a foundation for mathematics, Type Theory is a powerful tool for con- structively proving theorems with computerised verification. An example is the formal proof of the four-colour theorem by Georges Gonthier [42] 1. There are two versions of Martin-Löf type theory, the intensional version (Inten- sional Type Theory or ITT)
Recommended publications
  • Pragmatic Quotient Types in Coq Cyril Cohen
    Pragmatic Quotient Types in Coq Cyril Cohen To cite this version: Cyril Cohen. Pragmatic Quotient Types in Coq. International Conference on Interactive Theorem Proving, Jul 2013, Rennes, France. pp.16. hal-01966714 HAL Id: hal-01966714 https://hal.inria.fr/hal-01966714 Submitted on 29 Dec 2018 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Pragmatic Quotient Types in Coq Cyril Cohen Department of Computer Science and Engineering University of Gothenburg [email protected] Abstract. In intensional type theory, it is not always possible to form the quotient of a type by an equivalence relation. However, quotients are extremely useful when formalizing mathematics, especially in algebra. We provide a Coq library with a pragmatic approach in two complemen- tary components. First, we provide a framework to work with quotient types in an axiomatic manner. Second, we program construction mecha- nisms for some specific cases where it is possible to build a quotient type. This library was helpful in implementing the types of rational fractions, multivariate polynomials, field extensions and real algebraic numbers. Keywords: Quotient types, Formalization of mathematics, Coq Introduction In set-based mathematics, given some base set S and an equivalence ≡, one may see the quotient (S/ ≡) as the partition {π(x) | x ∈ S} of S into the sets π(x) ˆ= {y ∈ S | x ≡ y}, which are called equivalence classes.
    [Show full text]
  • Arithmetic in MIPS
    6 Arithmetic in MIPS Objectives After completing this lab you will: • know how to do integer arithmetic in MIPS • know how to do floating point arithmetic in MIPS • know about conversion from integer to floating point and from floating point to integer. Introduction The definition of the R2000 architecture includes all integer arithmetic within the actual CPU. Floating point arithmetic is done by one of the four possible coprocessors, namely coprocessor number 1. Integer arithmetic Addition and subtraction are performed on 32 bit numbers held in the general purpose registers (32 bit each). The result is a 32 bit number itself. Two kinds of instructions are included in the instruction set to do integer addition and subtraction: • instructions for signed arithmetic: the 32 bit numbers are considered to be represented in 2’s comple- ment. The execution of the instruction (addition or subtraction) may generate an overflow. • instructions for unsigned arithmetic: the 32 bit numbers are considered to be in standard binary repre- sentation. Executing the instruction will never generate an overflow error even if there is an actual overflow (the result cannot be represented with 32 bits). Multiplication and division may generate results that are larger than 32 bits. The architecture provides two special 32 bit registers that are the destination for multiplication and division instructions. These registers are called hi and lo as to indicate that they hold the higher 32 bits of the result and the lower 32 bits respectively. Special instructions are also provided to move data from these registers into the general purpose ones ($0 to $31).
    [Show full text]
  • Quotient Types: a Modular Approach
    Quotient Types: A Modular Approach Aleksey Nogin Department of Computer Science Cornell University, Ithaca, NY 14853 [email protected] Abstract. In this paper we introduce a new approach to axiomatizing quotient types in type theory. We suggest replacing the existing mono- lithic rule set by a modular set of rules for a specially chosen set of primitive operations. This modular formalization of quotient types turns out to be much easier to use and free of many limitations of the tradi- tional monolithic formalization. To illustrate the advantages of the new approach, we show how the type of collections (that is known to be very hard to formalize using traditional quotient types) can be naturally for- malized using the new primitives. We also show how modularity allows us to reuse one of the new primitives to simplify and enhance the rules for the set types. 1 Introduction NuPRL type theory differs from most other type theories used in theorem provers in its treatment of equality. In Coq’s Calculus of Constructions, for example, there is a single global equality relation which is not the desired one for many types (e.g. function types). The desired equalities have to be handled explicitly, which is quite burdensome. As in Martin-L¨of type theory [20] (of which NuPRL type theory is an extension), in NuPRL each type comes with its own equality relation (the extensional one in the case of functions), and the typing rules guar- antee that well–typed terms respect these equalities. Semantically, a quotient in NuPRL is trivial to define: it is simply a type with a new equality.
    [Show full text]
  • Towards a Proof-Irrelevant Calculus of Inductive Constructions Philipp Haselwarter
    Towards a Proof-Irrelevant Calculus of Inductive Constructions Philipp Haselwarter To cite this version: Philipp Haselwarter. Towards a Proof-Irrelevant Calculus of Inductive Constructions. Programming Languages [cs.PL]. 2014. hal-01114573v2 HAL Id: hal-01114573 https://hal.inria.fr/hal-01114573v2 Submitted on 4 Mar 2016 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Towards a Proof-Irrelevant Calculus of Inductive Constructions Philipp Haselwarter under the supervision of Matthieu Sozeau, PPS and 휋푟2 2nd September 2014 Summary The general context Through the Curry-Howard correspondence, dependent type theories are ap- pealing to both the mathematical and the programming community. To the first, they provide an expressive logical framework, in which mathematics can be developed. To the second, they offer a functional programming lan- guage that allows to state precise invariants programs have to respect and to build certified proofs thereof. Several dependent type systems have been investigated and implemented, with some early ones geared more towards the mathematical community [Con+86; Pol94; Coq12], called proof-assistants, and later putting a stronger accent on their viability as a programming environment [McB99; Nor07; Soz08]. The Calculus of Inductive Constructions (pCIC) is one such theory that attempts to stay faithful to the correspondence and bridge the two worlds of programming and proving.
    [Show full text]
  • Mathematics for Computer Scientists (G51MCS) Lecture Notes Autumn 2005
    Mathematics for Computer Scientists (G51MCS) Lecture notes Autumn 2005 Thorsten Altenkirch October 26, 2005 Contents 1 1 Types and sets What is a set? Wikipedia 1 says Informally, a set is just a collection of objects considered as a whole. And what is a type? Wikipedia offers different definitions for different subject areas, but if we look up datatype in Computer Science we learn: In computer science, a datatype (often simply type) is a name or label for a set of values and some operations which can be performed on that set of values. Here the meaning of type refers back to the meaning of sets, but it is hard to see a substantial difference. We may conclude that what is called a set in Mathematics is called a type in Computer Science. Here, we will adopt the computer science terminology and use the term type. But remember to translate this to set when talking to a Mathematician. There is a good reason for this choice: I am going to use the type system of the programming language Haskell to illustrate many important constructions on types and to implement mathematical constructions on a computer. Please note that this course is not an introduction to Haskell, this is done in the 2nd semester in G51FUN. If you want to find out more about Haskell now, I refer to Graham Hutton’s excellent, forthcoming book, whose first seven chapters are available from his web page 2 . The book is going to be published soon and is the course text for G51FUN. Another good source for information about Haskell is the Haskell home page 3 While we are going to use Haskell to illustrate mathematical concepts, Haskell is also a very useful language for lots of other things, from designing user interfaces to controlling robots.
    [Show full text]
  • Quotient Types — a Modular Approach *,**
    Quotient Types — a Modular Approach ?;?? Aleksey Nogin Department of Computer Science Cornell University Ithaca, NY 14853 E-mail: [email protected] Web: http://nogin.org/ Abstract. In this paper we introduce a new approach to defining quo- tient types in type theory. We suggest replacing the existing monolithic rule set by a modular set of rules for a specially chosen set of primitive operations. This modular formalization of quotient types turns out to be very powerful and free of many limitations of the traditional monolithic formalization. To illustrate the advantages of the new formalization, we show how the type of collections (that is known to be very hard to formal- ize using traditional quotient types) can be naturally formalized using the new primitives. We also show how modularity allows us to reuse one of the new primitives to simplify and enhance the rules for the set types. 1 Introduction NuPRL type theory differs from most other type theories used in theorem provers in its treatment of equality. In Coq’s Calculus of Constructions, for example, there is a single global equality relation which is not the desired one for many types (e.g. function types). The desired equalities have to be handled explicitly, which is quite burdensome. As in Martin-L¨oftype theory [17] (of which NuPRL type theory is an extension), in NuPRL each type comes with its own equality relation (the extensional one in the case of functions), and the typing rules guar- antee that well–typed terms respect these equalities. Semantically, a quotient in NuPRL is trivial to define: it is simply a type with a new equality.
    [Show full text]
  • Quotient Types
    Quotient Types Peter V. Homeier U. S. Department of Defense, [email protected] http://www.cis.upenn.edu/~homeier Abstract. The quotient operation is a standard feature of set theory, where a set is divided into subsets by an equivalence relation; the re- sulting subsets of equivalent elements are called equivalence classes. We reinterpret this idea for Higher Order Logic (HOL), where types are di- vided by an equivalence relation to create new types, called quotient types. We present a tool for the Higher Order Logic theorem prover to mechanically construct quotient types as new types in the HOL logic, and also to de¯ne functions that map between the original type and the quotient type. Several properties of these mapping functions are proven automatically. Tools are also provided to create quotients of aggregate types, in particular lists, pairs, and sums. These require special atten- tion to preserve the aggregate structure across the quotient operation. We demonstrate these tools on an example from the sigma calculus. 1 Quotient Sets Quotient sets are a standard construction of set theory. They have found wide application in many areas of mathematics, including algebra and logic. The following description is abstracted from [3]. A binary relation on S is an equivalence relation if it is reflexive, symmetric, and transitive. » reflexive: x S: x x symmetric: 8x;2 y S: x » y y x transitive: 8x; y;2 z S: x » y ) y »z x z 8 2 » ^ » ) » Let be an equivalence relation. Then the equivalence class of x (modulo )is » » de¯ned as [x] def= y x y .
    [Show full text]
  • Structured Formal Development with Quotient Types in Isabelle/HOL
    Structured Formal Development with Quotient Types in Isabelle/HOL Maksym Bortin1 and Christoph Lüth2 1 Universität Bremen, Department of Mathematics and Computer Science [email protected] 2 Deutsches Forschungszentrum für Künstliche Intelligenz, Bremen [email protected] Abstract. General purpose theorem provers provide sophisticated proof methods, but lack some of the advanced structuring mechanisms found in specification languages. This paper builds on previous work extending the theorem prover Isabelle with such mechanisms. A way to build the quotient type over a given base type and an equivalence relation on it, and a generalised notion of folding over quotiented types is given as a formalised high-level step called a design tactic. The core of this paper are four axiomatic theories capturing the design tactic. The applicability is demonstrated by derivations of implementations for finite multisets and finite sets from lists in Isabelle. 1 Introduction Formal development of correct systems requires considerable design and proof effort in order to establish that an implementation meets the required specifi- cation. General purpose theorem provers provide powerful proof methods, but often lack the advanced structuring and design concepts found in specification languages, such as design tactics [20]. A design tactic represents formalised de- velopment knowledge. It is an abstract development pattern proven correct once and for all, saving proof effort when applying it and guiding the development process. If theorem provers can be extended with similar concepts without loss of consistency, the development process can be structured within the prover. This paper is a step in this direction. Building on previous work [2] where an approach to the extension of the theorem prover Isabelle [15] with theory morphisms has been described, the contributions of this paper are the representation of the well-known type quotienting construction and its extension with a generalised notion of folding over the quotiented type as a design tactic.
    [Show full text]
  • Defining Functions on Equivalence Classes
    Defining Functions on Equivalence Classes LAWRENCE C. PAULSON University of Cambridge A quotient construction defines an abstract type from a concrete type, using an equivalence relation to identify elements of the concrete type that are to be regarded as indistinguishable. The elements of a quotient type are equivalence classes: sets of equivalent concrete values. Simple techniques are presented for defining and reasoning about quotient constructions, based on a general lemma library concerning functions that operate on equivalence classes. The techniques are applied to a definition of the integers from the natural numbers, and then to the definition of a recursive datatype satisfying equational constraints. Categories and Subject Descriptors: F.4.1 [Mathematical Logic]: Mechanical theorem proving; G2.0 [Discrete Mathematics]: General General Terms: Theory; Verification Additional Key Words and Phrases: equivalence classes, quotients, theorem proving 1. INTRODUCTION Equivalence classes and quotient constructions are familiar to every student of discrete mathematics. They are frequently used for defining abstract objects. A typical example from the λ-calculus is α-equivalence, which identifies terms that differ only by the names of bound variables. Strictly speaking, we represent a term by the set of all terms that can be obtained from it by renaming variables. In order to define a function on terms, we must show that the result is independent of the choice of variable names. Here we see the drawbacks of using equivalence classes: individuals are represented by sets and function definitions carry a proof obligation. Users of theorem proving tools are naturally inclined to prefer concrete methods whenever possible. With their backgrounds in computer science, they will see func- tions as algorithms and seek to find canonical representations of elements.
    [Show full text]
  • Homotopy Type-Theoretic Interpretations of Constructive Set Theories
    Homotopy Type-Theoretic Interpretations of Constructive Set Theories Cesare Gallozzi Submitted in accordance with the requirements for the degree of Doctor of Philosophy The University of Leeds School of Mathematics July 2018 The candidate confirms that the work submitted is his own and that appropriate credit has been given where reference has been made to the work of others. This copy has been supplied on the understanding that it is copyright material and that no quotation from the thesis may be published without proper acknowledge- ment. c 2018, The University of Leeds and Cesare Gallozzi The right of Cesare Gallozzi to be identified as author of this work has been asserted by him in accordance with the Copyright, Designs and Patents Act 1988. To all my teachers. Acknowledgements I wish to thank all those who made this thesis possible. I thank all my teachers and in particular my supervisor Nicola Gambino for his tireless generosity and all the help and guidance he offered during the course of the PhD. I thank the University of Leeds and the School of Mathematics for their financial support. I thank all those who contributed to improve this thesis by answering my ques- tions or making comments on the material: my co-supervisor Michael Rathjen, and also Peter Hancock, John Truss, Stan Wainer, Martin Hofmann, Helmut Schwichtenberg, Michael Toppel, Anton Freund, Andrew Swan, Jakob Vidmar, Nicolai Kraus and Fredrik Nordvall Forsberg. I thank my parents and my grandmother for all their care and for encouraging my interests in science and mathematics since my early childhood.
    [Show full text]
  • Arxiv:1710.10685V3
    EXACT COMPLETION AND CONSTRUCTIVE THEORIES OF SETS JACOPO EMMENEGGER AND ERIK PALMGREN† Abstract. In the present paper we use the theory of exact completions to study cat- egorical properties of small setoids in Martin-Löf type theory and, more generally, of models of the Constructive Elementary Theory of the Category of Sets, in terms of prop- erties of their subcategories of choice objects (i.e. objects satisfying the axiom of choice). Because of these intended applications, we deal with categories that lack equalisers and just have weak ones, but whose objects can be regarded as collections of global elements. In this context, we study the internal logic of the categories involved, and employ this analysis to give a sufficient condition for the local cartesian closure of an exact comple- tion. Finally, we apply this result to show when an exact completion produces a model of CETCS. 1. Introduction Following a tradition initiated by Bishop [7], the constructive notion of set is taken to be a collection of elements together with an equivalence relation on it, seen as the equality of the set. In Martin-Löf type theory this is realised with the notion of setoid, which consists of a type together with a type-theoretic equivalence relation on it [31]. An ancestor of this construction can be found in Gandy’s interpretation of the extensional theory of simple types into the intensional one [15]. A category-theoretic counterpart is provided by the exact completion construction Cex, which freely adds quotients of equivalence relations to a category C with (weak) finite limits [9, 11].
    [Show full text]
  • An Implementation of Effective Homotopy of Fibrations
    An implementation of effective homotopy of fibrations Ana Romero University of La Rioja, Spain Julio Rubio University of La Rioja, Spain Francis Sergeraert Université Joseph Fourier, France Abstract In this paper, we present a new module for the Kenzo system which makes it possible to com- pute the effective homotopy of the total space of a fibration, using the well-known long exact sequence of homotopy of a fibration defined by Jean-Pierre Serre. The programs are written in Common Lisp and require the implementation of new classes and functions corresponding to the definitions of setoid group (SG) and effective setoid group (ESG). Moreover, we have included a new module for working with finitely generated abelian groups, choosing the representation of a free presentation by means of a matrix in canonical form. These tools are then used to implement the long exact homotopy sequence of a fibration. We illustrate with examples some applications of our results. Keywords: Constructive algebraic topology, effective homotopy, fibrations, homotopy groups, Serre exact sequence, finitely generated groups, central extensions, setoid groups, effective setoid groups. 1. Introduction The problem of computing homology groups of topological spaces is well-known to be dif- ficult, for example when loop spaces or classifying spaces are involved. In particular, knowing the homology groups of a topological group or space does not imply that the homology groups of its classifying space or loop space can also be determined. In the same way, given a fibration F ,! E ! B, there does not exist a general algorithm computing the homology groups of E from the homology groups of B and F.
    [Show full text]