diff --git a/.github/workflows/Tests.yml b/.github/workflows/Tests.yml index ae95d0eab0..4c5eebfdc0 100644 --- a/.github/workflows/Tests.yml +++ b/.github/workflows/Tests.yml @@ -58,6 +58,7 @@ jobs: if [ -d "CAP_project/CompilerForCAP" ]; then make -C "CAP_project/CompilerForCAP" doc; fi if [ -d "CAP_project/MonoidalCategories" ]; then make -C "CAP_project/MonoidalCategories" doc; fi if [ -d "CAP_project/CartesianCategories" ]; then make -C "CAP_project/CartesianCategories" doc; fi + if [ -d "CAP_project/AdditiveClosuresForCAP" ]; then make -C "CAP_project/AdditiveClosuresForCAP" doc; fi if [ -d "CAP_project/FreydCategoriesForCAP" ]; then make -C "CAP_project/FreydCategoriesForCAP" doc; fi if [ -d "HigherHomologicalAlgebra/ToolsForHigherHomologicalAlgebra" ]; then make -C "HigherHomologicalAlgebra/ToolsForHigherHomologicalAlgebra" doc; fi if [ -d "homalg_project/homalg" ]; then make -C "homalg_project/homalg" doc; fi diff --git a/AdditiveClosuresForCAP/.gitignore b/AdditiveClosuresForCAP/.gitignore new file mode 100644 index 0000000000..8f5a42dbda --- /dev/null +++ b/AdditiveClosuresForCAP/.gitignore @@ -0,0 +1,34 @@ +/doc/chap*.html +/doc/chap*.txt +/doc/*.css +/doc/*.js +/doc/chooser.html +/doc/*.aux +/doc/*.bbl +/doc/*.blg +/doc/*.brf +/doc/*.idx +/doc/*.ilg +/doc/*.ind +/doc/*.lab +/doc/*.log +/doc/*.out +/doc/*.pnr +/doc/*.six +/doc/*.tex +/doc/*.toc +/doc/manual.pdf +/doc/_*.xml + +/bin/ +/gen/ +/Makefile + +/tmp/ +/gh-pages/ + +/coverage.json +/doc/*.xml +/doc_tmp/ +/stats +/tst/additiveclosuresforcap*.tst diff --git a/AdditiveClosuresForCAP/LICENSE b/AdditiveClosuresForCAP/LICENSE new file mode 100644 index 0000000000..d159169d10 --- /dev/null +++ b/AdditiveClosuresForCAP/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/AdditiveClosuresForCAP/PackageInfo.g b/AdditiveClosuresForCAP/PackageInfo.g new file mode 100644 index 0000000000..8bdfa09709 --- /dev/null +++ b/AdditiveClosuresForCAP/PackageInfo.g @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# This file contains package meta data. For additional information on +# the meaning and correct usage of these fields, please consult the +# manual of the "Example" package as well as the comments in its +# PackageInfo.g file. +# +SetPackageInfo( rec( + +PackageName := "AdditiveClosuresForCAP", +Subtitle := "Additive closures for pre-abelian categories", +Version := "2025.06-01", +Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), +License := "GPL-2.0-or-later", + +Persons := [ + rec( + IsAuthor := true, + IsMaintainer := true, + FirstNames := "Sebastian", + LastName := "Posur", + WWWHome := "https://sebastianpos.github.io", + Email := "sebastian.posur@uni-siegen.de", + PostalAddress := Concatenation( + "Department Mathematik\n", + "Universität Siegen\n", + "Walter-Flex-Straße 3\n", + "57068 Siegen\n", + "Germany" ), + Place := "Siegen", + Institution := "University of Siegen", + ), + rec( + IsAuthor := true, + IsMaintainer := true, + FirstNames := "Martin", + LastName := "Bies", + WWWHome := "https://www.ulb.ac.be/sciences/ptm/pmif/people.html", + Email := "martin.bies@alumni.uni-heidelberg.de", + PostalAddress := Concatenation( + "Physique Théorique et Mathématique \n", + "Université Libre de Bruxelles \n", + "Campus Plaine - CP 231 \n", + "Building NO - Level 6 - Office O.6.111 \n", + "1050 Brussels \n", + "Belgium" ), + Place := "Brussels", + Institution := "ULB Brussels", + ), + rec( + IsAuthor := true, + IsMaintainer := true, + FirstNames := "Mohamed", + LastName := "Barakat", + WWWHome := "https://mohamed-barakat.github.io", + Email := "mohamed.barakat@uni-siegen.de", + PostalAddress := Concatenation( + "Walter-Flex-Str. 3\n", + "57068 Siegen\n", + "Germany" ), + Place := "Siegen", + Institution := "University of Siegen", + ), + rec( + IsAuthor := true, + IsMaintainer := true, + FirstNames := "Kamal", + LastName := "Saleh", + WWWHome := "https://github.com/kamalsaleh", + Email := "kamal.saleh@uni-siegen.de", + PostalAddress := Concatenation( + "Department Mathematik\n", + "Universität Siegen\n", + "Walter-Flex-Straße 3\n", + "57072 Siegen\n", + "Germany" ), + Place := "Siegen", + Institution := "Universität Siegen", + ), + rec( + IsAuthor := true, + IsMaintainer := true, + FirstNames := "Fabian", + LastName := "Zickgraf", + WWWHome := "https://github.com/zickgraf/", + Email := "fabian.zickgraf@uni-siegen.de", + PostalAddress := Concatenation( + "Walter-Flex-Str. 3\n", + "57068 Siegen\n", + "Germany" ), + Place := "Siegen", + Institution := "University of Siegen", + ), +], + +# BEGIN URLS +SourceRepository := rec( + Type := "git", + URL := "https://github.com/homalg-project/CAP_project", +), +IssueTrackerURL := Concatenation( ~.SourceRepository.URL, "/issues" ), +PackageWWWHome := "https://homalg-project.github.io/pkg/AdditiveClosuresForCAP", +PackageInfoURL := "https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/PackageInfo.g", +README_URL := "https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/README.md", +ArchiveURL := Concatenation( "https://github.com/homalg-project/CAP_project/releases/download/AdditiveClosuresForCAP-", ~.Version, "/AdditiveClosuresForCAP-", ~.Version ), +# END URLS + +ArchiveFormats := ".tar.gz .zip", + +## Status information. Currently the following cases are recognized: +## "accepted" for successfully refereed packages +## "submitted" for packages submitted for the refereeing +## "deposited" for packages for which the GAP developers agreed +## to distribute them with the core GAP system +## "dev" for development versions of packages +## "other" for all other packages +## +Status := "dev", + +AbstractHTML := "", + +PackageDoc := rec( + BookName := "AdditiveClosuresForCAP", + ArchiveURLSubset := ["doc"], + HTMLStart := "doc/chap0.html", + PDFFile := "doc/manual.pdf", + SixFile := "doc/manual.six", + LongTitle := "Additive closures for pre-abelian categories", +), + +Dependencies := rec( + GAP := ">= 4.13.0", + NeededOtherPackages := [ [ "CAP", ">= 2025.06-05" ], + [ "GradedRingForHomalg", ">=2019.08.07" ], + [ "MonoidalCategories", ">= 2024.09-02" ], + ], + SuggestedOtherPackages := [ ], + ExternalConditions := [ ], +), + +Extensions := [ +], + +AvailabilityTest := function() + return true; + end, +#Keywords := [ "TODO" ], + +TestFile := "tst/testall.g", + +)); diff --git a/AdditiveClosuresForCAP/README.md b/AdditiveClosuresForCAP/README.md new file mode 100644 index 0000000000..b357fa1c6b --- /dev/null +++ b/AdditiveClosuresForCAP/README.md @@ -0,0 +1,44 @@ + +# AdditiveClosuresForCAP [![View code][code-img]][code-url] + +### Additive closures for pre-abelian categories + +| Documentation | Latest Release | Build Status of [CAP_project](/../../) | Code Coverage | +| ------------- | -------------- | ------------ | ------------- | +| [![HTML stable documentation][html-img]][html-url] [![PDF stable documentation][pdf-img]][pdf-url] | [![version][version-img]][version-url] [![date][date-img]][date-url] | [![Build Status][tests-img]][tests-url] | [![Code Coverage][codecov-img]][codecov-url] | + + + +This package includes an implementation of: +- [Additive closures](#additive-closures) + +## Additive closures + +Additive closures provide a universal way of equipping a given Ab-category with finite direct sums. + +#### Paper (describing the underlying algorithms) + +Sebastian Posur, [*Methods of constructive category theory*](https://arxiv.org/abs/1908.04132). + + +[html-img]: https://img.shields.io/badge/🔗%20HTML-stable-blue.svg +[html-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/doc/chap0_mj.html + +[pdf-img]: https://img.shields.io/badge/🔗%20PDF-stable-blue.svg +[pdf-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/download_pdf.html + +[version-img]: https://img.shields.io/endpoint?url=https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/badge_version.json&label=🔗%20version&color=yellow +[version-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/view_release.html + +[date-img]: https://img.shields.io/endpoint?url=https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/badge_date.json&label=🔗%20released%20on&color=yellow +[date-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/view_release.html + +[tests-img]: https://github.com/homalg-project/CAP_project/actions/workflows/Tests.yml/badge.svg?branch=master +[tests-url]: https://github.com/homalg-project/CAP_project/actions/workflows/Tests.yml?query=branch%3Amaster + +[codecov-img]: https://codecov.io/gh/homalg-project/CAP_project/branch/master/graph/badge.svg?flag=AdditiveClosuresForCAP +[codecov-url]: https://app.codecov.io/gh/homalg-project/CAP_project/tree/master/AdditiveClosuresForCAP + +[code-img]: https://img.shields.io/badge/-View%20code-blue?logo=github +[code-url]: https://github.com/homalg-project/CAP_project/tree/master/AdditiveClosuresForCAP#top + diff --git a/AdditiveClosuresForCAP/doc/Doc.autodoc b/AdditiveClosuresForCAP/doc/Doc.autodoc new file mode 100644 index 0000000000..9423c31a63 --- /dev/null +++ b/AdditiveClosuresForCAP/doc/Doc.autodoc @@ -0,0 +1,53 @@ +@Chapter Rings as categories + +@Section GAP Categories +@Section Constructors +@Section Attributes +@Section Operations +@Section Random methods + +@Chapter Additive closure +@Section Constructors +@Section Attributes +@Section Operators +@Section Global functions +@Section Random methods for additive closure category +@Section GAP Categories + +@Chapter Example on additive closure + +@Chapter Category of rows +@Section Constructors +@Section Attributes +@Section Global functions +@Section Random Methods in Category of Rows +@Section GAP Categories +@Section Supported CAP operations +@Subsection CategoryOfRows of an arbitrary ring +@Subsection CategoryOfRows of an exterior algebra over a field +@Subsection CategoryOfRows of a commutative ring +@Subsection CategoryOfRows of a field + +@Chapter Example on category of rows + +@Chapter Category of columns +@Section Constructors +@Section Attributes +@Section GAP Categories + +@Chapter Example on category of columns + +@Chapter Category of rows and columns over a field +@Section Abelian operations + +@Chapter Category of graded rows and category of graded columns +@Section Constructors +@Section Attributes + +@Chapter Examples on graded rows and columns + +@Chapter Basic operations + +@Chapter Examples and Tests + +@Chapter Add Functions diff --git a/AdditiveClosuresForCAP/doc/clean b/AdditiveClosuresForCAP/doc/clean new file mode 100755 index 0000000000..ffe1f90868 --- /dev/null +++ b/AdditiveClosuresForCAP/doc/clean @@ -0,0 +1,2 @@ +#!/bin/sh +rm -f *.{aux,bbl,blg,brf,css,html,idx,ilg,ind,js,lab,log,out,pdf,pnr,six,tex,toc,txt,xml,xml.bib} diff --git a/FreydCategoriesForCAP/examples/AdditiveClosure.g b/AdditiveClosuresForCAP/examples/AdditiveClosure.g similarity index 98% rename from FreydCategoriesForCAP/examples/AdditiveClosure.g rename to AdditiveClosuresForCAP/examples/AdditiveClosure.g index 610257965b..eea5181a74 100644 --- a/FreydCategoriesForCAP/examples/AdditiveClosure.g +++ b/AdditiveClosuresForCAP/examples/AdditiveClosure.g @@ -2,7 +2,7 @@ #! @Section Using matrix data structures -LoadPackage( "FreydCategoriesForCAP" );; +LoadPackage( "AdditiveClosuresForCAP" );; #! @Example QQ := HomalgFieldOfRationalsInSingular();; diff --git a/FreydCategoriesForCAP/examples/AdditiveClosureKronecker.g b/AdditiveClosuresForCAP/examples/AdditiveClosureKronecker.g similarity index 95% rename from FreydCategoriesForCAP/examples/AdditiveClosureKronecker.g rename to AdditiveClosuresForCAP/examples/AdditiveClosureKronecker.g index 200d9ae10a..a355d24d69 100644 --- a/FreydCategoriesForCAP/examples/AdditiveClosureKronecker.g +++ b/AdditiveClosuresForCAP/examples/AdditiveClosureKronecker.g @@ -3,7 +3,7 @@ #! @Section Monoidal structure of AdditiveClosure #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true Q := HomalgFieldOfRationals();; R := RingAsCategory( Q ); diff --git a/FreydCategoriesForCAP/examples/AdditiveClosureMonoidal.g b/AdditiveClosuresForCAP/examples/AdditiveClosureMonoidal.g similarity index 98% rename from FreydCategoriesForCAP/examples/AdditiveClosureMonoidal.g rename to AdditiveClosuresForCAP/examples/AdditiveClosureMonoidal.g index 89210dc299..38b9d2eb5d 100644 --- a/FreydCategoriesForCAP/examples/AdditiveClosureMonoidal.g +++ b/AdditiveClosuresForCAP/examples/AdditiveClosureMonoidal.g @@ -3,7 +3,7 @@ #! @Section Monoidal structure of AdditiveClosure #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true T := TerminalCategoryWithMultipleObjects( ); #! TerminalCategoryWithMultipleObjects( ) diff --git a/AdditiveClosuresForCAP/examples/Basics.gi b/AdditiveClosuresForCAP/examples/Basics.gi new file mode 100644 index 0000000000..fd3949c366 --- /dev/null +++ b/AdditiveClosuresForCAP/examples/Basics.gi @@ -0,0 +1,200 @@ +#! @Chapter Examples and Tests + +#! @Section Basics based on category of rows + +#! @Example +LoadPackage( "RingsForHomalg", false ); +#! true +LoadPackage( "AdditiveClosuresForCAP", false ); +#! true +R := HomalgRingOfIntegers();; +cat := CategoryOfRows( R );; +obj1 := CategoryOfRowsObject( 1, cat );; +obj2 := CategoryOfRowsObject( 2, cat );; +IsIsomorphicForObjects( obj1, obj2 ); +#! false +IsIsomorphicForObjects( obj2, obj2 ); +#! true +IsIsomorphism( SomeIsomorphismBetweenObjects( obj2, obj2 ) ); +#! true +id := IdentityMorphism( obj2 );; +alpha := CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );; +beta := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );; +comp := PreCompose( alpha, beta );; +IsZeroForMorphisms( comp );; +zero := ZeroMorphism( obj1, obj2 );; +IsZeroForMorphisms( zero );; +ZeroObject( cat );; +UniversalMorphismIntoZeroObject( obj2 );; +UniversalMorphismFromZeroObject( obj1 );; +IsCongruentForMorphisms( + SumOfMorphisms( obj1, [ alpha, alpha, alpha ], obj2 ), + AdditionForMorphisms( alpha, AdditionForMorphisms( alpha, alpha ) ) +); +#! true +IsCongruentForMorphisms( + SumOfMorphisms( obj1, [ ], obj2 ), + ZeroMorphism( obj1, obj2 ) +); +#! true +DirectSum( obj1, obj2 );; +DirectSumFunctorial( [ alpha, beta, id ] );; +proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );; +IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 3 ) ); +#! true +UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );; +inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );; +IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 3 ) ); +#! true +gamma := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );; +IsColiftable( beta, gamma ); +#! true +IsColiftable( gamma, beta ); +#! false +ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );; +ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );; +lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );; +lift_arg_2 := gamma + gamma;; +IsLiftable( lift_arg_1, lift_arg_2 );; +Lift( lift_arg_1, lift_arg_2 );; +pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );; +pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );; +IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );; +inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );; +inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );; +IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );; +WeakKernelLift( WeakCokernelProjection( gamma ), gamma );; +pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );; +pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );; +UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );; + +S := HomalgFieldOfRationalsInSingular() * "x,y,z";; +Rows_S := CategoryOfRows( S );; +S3 := CategoryOfRowsObject( 3, Rows_S );; +S1 := CategoryOfRowsObject( 1, Rows_S );; +mor := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,y,z]", 3, 1, S ), S1 );; +biased_w := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );; +biased_h := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );; +BiasedWeakFiberProduct( biased_h, biased_w );; +ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );; +IsCongruentForMorphisms( + PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ), + biased_h +); +#! true +IsCongruentForMorphisms( + PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )), + biased_h +); +#! true + +## Homomorphism structures +a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );; +IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; +a := ZeroObjectFunctorial( cat );; +IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; +#! @EndExample + +#! @Section Basics based on category of columns + +#! @Example +R := HomalgRingOfIntegers();; +cat := CategoryOfColumns( R );; +obj1 := CategoryOfColumnsObject( 1, cat );; +obj2 := CategoryOfColumnsObject( 2, cat );; +id := IdentityMorphism( obj2 );; +alpha := CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 1, 2, R ), obj2 );; +beta := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );; +comp := PreCompose( alpha, beta );; +IsZeroForMorphisms( comp );; +zero := ZeroMorphism( obj1, obj2 );; +IsZeroForMorphisms( zero );; +ZeroObject( cat );; +UniversalMorphismIntoZeroObject( obj2 );; +UniversalMorphismFromZeroObject( obj1 );; +DirectSum( obj1, obj2 );; +DirectSumFunctorial( [ alpha, beta, id ] );; +proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );; +IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) ); +#! true +UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );; +inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );; +IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) ); +#! true +IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) ); +#! true +IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) ); +#! true +gamma := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );; +IsColiftable( beta, gamma ); +#! false +IsColiftable( gamma, beta ); +#! false +ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );; +ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );; +lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );; +lift_arg_2 := gamma + gamma;; +IsLiftable( lift_arg_1, lift_arg_2 );; +Lift( lift_arg_1, lift_arg_2 );; +pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );; +pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );; +IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );; +inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );; +inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );; +IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );; +WeakKernelLift( WeakCokernelProjection( gamma ), gamma );; +pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );; +pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );; +UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );; + + +S := HomalgFieldOfRationalsInSingular() * "x,y,z";; +Cols_S := CategoryOfColumns( S );; +S3 := CategoryOfColumnsObject( 3, Cols_S );; +S1 := CategoryOfColumnsObject( 1, Cols_S );; +mor := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,y,z]", 1, 3, S ), S1 );; +biased_w := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );; +biased_h := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );; +BiasedWeakFiberProduct( biased_h, biased_w );; +ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );; +IsCongruentForMorphisms( + PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ), + biased_h +); +#! true +IsCongruentForMorphisms( + PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )), + biased_h +); +#! true + +## Homomorphism structures +a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );; +IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; +a := ZeroObjectFunctorial( cat );; +IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; +#! @EndExample diff --git a/FreydCategoriesForCAP/examples/CategoryOfColumns.g b/AdditiveClosuresForCAP/examples/CategoryOfColumns.g similarity index 98% rename from FreydCategoriesForCAP/examples/CategoryOfColumns.g rename to AdditiveClosuresForCAP/examples/CategoryOfColumns.g index 42498a0226..9e912516b9 100644 --- a/FreydCategoriesForCAP/examples/CategoryOfColumns.g +++ b/AdditiveClosuresForCAP/examples/CategoryOfColumns.g @@ -1,7 +1,6 @@ #! @Chapter Example on category of columns -LoadPackage( "FreydCategoriesForCAP" );; -LoadPackage( "RingsForHomalg" ); +LoadPackage( "AdditiveClosuresForCAP" );; ##################################### #! @Section Constructors of objects @@ -17,7 +16,6 @@ obj2 := CategoryOfColumnsObject( 8, cols ); #! #! @EndExample - ##################################### #! @Section Constructors of morphisms ##################################### @@ -45,10 +43,6 @@ Display( UnderlyingMatrix( mor ) ); #! [ 2 ] ] #! @EndLog - - - - ######################################################################## #! @Section A few categorical constructions for category of columns ######################################################################## diff --git a/FreydCategoriesForCAP/examples/CategoryOfRows.g b/AdditiveClosuresForCAP/examples/CategoryOfRows.g similarity index 99% rename from FreydCategoriesForCAP/examples/CategoryOfRows.g rename to AdditiveClosuresForCAP/examples/CategoryOfRows.g index 3a36826f2b..6e34516524 100644 --- a/FreydCategoriesForCAP/examples/CategoryOfRows.g +++ b/AdditiveClosuresForCAP/examples/CategoryOfRows.g @@ -1,7 +1,7 @@ #! @Chapter Example on category of rows -LoadPackage( "FreydCategoriesForCAP" );; LoadPackage( "RingsForHomalg" ); +LoadPackage( "AdditiveClosuresForCAP" );; ##################################### #! @Section Constructors of objects @@ -17,7 +17,6 @@ obj2 := CategoryOfRowsObject( 8, rows ); #! #! @EndExample - ##################################### #! @Section Constructors of morphisms ##################################### @@ -44,10 +43,6 @@ Display( UnderlyingMatrix( mor ) ); #! [ [ 1, 2 ] ] #! @EndLog - - - - ######################################################################## #! @Section A few categorical constructions for category of rows ######################################################################## diff --git a/FreydCategoriesForCAP/examples/GradedRowsAndColumns.g b/AdditiveClosuresForCAP/examples/GradedRowsAndColumns.g similarity index 99% rename from FreydCategoriesForCAP/examples/GradedRowsAndColumns.g rename to AdditiveClosuresForCAP/examples/GradedRowsAndColumns.g index a419a799fa..fc97d80d76 100644 --- a/FreydCategoriesForCAP/examples/GradedRowsAndColumns.g +++ b/AdditiveClosuresForCAP/examples/GradedRowsAndColumns.g @@ -4,9 +4,7 @@ ################################################################# ################################################################# -LoadPackage( "FreydCategoriesForCAP" );; - - +LoadPackage( "AdditiveClosuresForCAP" );; ################################################################# #! @Section Constructors of objects and reduction of degree lists diff --git a/FreydCategoriesForCAP/examples/HomStructureTest.g b/AdditiveClosuresForCAP/examples/HomStructureTest.g similarity index 97% rename from FreydCategoriesForCAP/examples/HomStructureTest.g rename to AdditiveClosuresForCAP/examples/HomStructureTest.g index a7fda1e65e..244be7e830 100644 --- a/FreydCategoriesForCAP/examples/HomStructureTest.g +++ b/AdditiveClosuresForCAP/examples/HomStructureTest.g @@ -3,10 +3,10 @@ #! @Section Homomorphism structure #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); -#! true LoadPackage( "RingsForHomalg", false ); #! true +LoadPackage( "AdditiveClosuresForCAP", false ); +#! true EEE := KoszulDualRing( HomalgFieldOfRationalsInSingular( ) * "x,y" );; Eoid := RingAsCategory( EEE );; a := RingAsCategoryMorphism( Eoid, 1/2 );; diff --git a/FreydCategoriesForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g b/AdditiveClosuresForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g similarity index 98% rename from FreydCategoriesForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g rename to AdditiveClosuresForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g index aafd0ad20d..255110c7ce 100644 --- a/FreydCategoriesForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g +++ b/AdditiveClosuresForCAP/examples/Opposite_CategoryOfRows_as_CategoryOfColumns.g @@ -10,7 +10,7 @@ #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true QQ := HomalgFieldOfRationals( );; diff --git a/FreydCategoriesForCAP/examples/Random.g b/AdditiveClosuresForCAP/examples/Random.g similarity index 94% rename from FreydCategoriesForCAP/examples/Random.g rename to AdditiveClosuresForCAP/examples/Random.g index aa0bdb32b0..279f9229ab 100644 --- a/FreydCategoriesForCAP/examples/Random.g +++ b/AdditiveClosuresForCAP/examples/Random.g @@ -3,7 +3,7 @@ #! @Section Tests #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true R := HomalgRingOfIntegers( ) ;; cat := CategoryOfColumns( R );; diff --git a/FreydCategoriesForCAP/examples/RingsAsAbCats.g b/AdditiveClosuresForCAP/examples/RingsAsAbCats.g similarity index 98% rename from FreydCategoriesForCAP/examples/RingsAsAbCats.g rename to AdditiveClosuresForCAP/examples/RingsAsAbCats.g index 6c99d55298..07ead3db4c 100644 --- a/FreydCategoriesForCAP/examples/RingsAsAbCats.g +++ b/AdditiveClosuresForCAP/examples/RingsAsAbCats.g @@ -2,7 +2,7 @@ #! @Section Rings as Ab-categories -LoadPackage( "FreydCategoriesForCAP" );; +LoadPackage( "AdditiveClosuresForCAP" );; #! @Example CR := RingAsCategory( Integers );; diff --git a/FreydCategoriesForCAP/examples/RowsAndColsOverFields.g b/AdditiveClosuresForCAP/examples/RowsAndColsOverFields.g similarity index 98% rename from FreydCategoriesForCAP/examples/RowsAndColsOverFields.g rename to AdditiveClosuresForCAP/examples/RowsAndColsOverFields.g index 139ed8e5d1..79cfc72709 100644 --- a/FreydCategoriesForCAP/examples/RowsAndColsOverFields.g +++ b/AdditiveClosuresForCAP/examples/RowsAndColsOverFields.g @@ -1,8 +1,8 @@ #! @Chapter Category of rows and columns over a field -#! @Section Abelian operations for rows +#! @Section Abelian operations -LoadPackage( "FreydCategoriesForCAP" );; +LoadPackage( "AdditiveClosuresForCAP" );; #! Category of rows over a field diff --git a/AdditiveClosuresForCAP/examples/Simplify.g b/AdditiveClosuresForCAP/examples/Simplify.g new file mode 100644 index 0000000000..271e67506a --- /dev/null +++ b/AdditiveClosuresForCAP/examples/Simplify.g @@ -0,0 +1,83 @@ +#! @Chapter Example on category of rows + +LoadPackage( "RingsForHomalg" ); +LoadPackage( "AdditiveClosuresForCAP" );; + +##################################### +#! @Section Simplifications +##################################### + +#! @Example +R := HomalgRingOfIntegers();; +rows := CategoryOfRows( R );; +M := HomalgMatrix( [ [ 2, 2, 2 ], [ 3, 3, 3 ] ], 2, 3, R );; +alpha := AsCategoryOfRowsMorphism( M, rows );; +pi := PreCompose( [ + SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), + SimplifySourceAndRange( alpha, infinity ), + SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ] );; +IsCongruentForMorphisms( pi, alpha ); +#! true +IsOne( + PreCompose( SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), SimplifySourceAndRange_IsoToInputSource( alpha, infinity ) ) +); +#! true +IsOne( + PreCompose( SimplifySourceAndRange_IsoFromInputRange( alpha, infinity ), SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ) +); +#! true +pi2 := PreCompose( + SimplifySource_IsoFromInputObject( alpha, infinity ), + SimplifySource( alpha, infinity ) +);; +IsCongruentForMorphisms( pi2, alpha ); +#! true +IsOne( PreCompose( SimplifySource_IsoFromInputObject( alpha, infinity ), SimplifySource_IsoToInputObject( alpha, infinity ) ) ); +#! true +pi3 := PreCompose( + SimplifyRange( alpha, infinity ), + SimplifyRange_IsoToInputObject( alpha, infinity ) +);; +IsCongruentForMorphisms( pi3, alpha ); +#! true +IsOne( PreCompose( SimplifyRange_IsoFromInputObject( alpha, infinity ), SimplifyRange_IsoToInputObject( alpha, infinity ) ) ); +#! true +#! @EndExample + +#! @Example +R := HomalgRingOfIntegers();; +cols := CategoryOfColumns( R );; +M := HomalgMatrix( [ [ 2, 2, 2 ], [ 3, 3, 3 ] ], 2, 3, R );; +alpha := AsCategoryOfColumnsMorphism( M, cols );; +pi := PreCompose( [ + SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), + SimplifySourceAndRange( alpha, infinity ), + SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ] );; +IsCongruentForMorphisms( pi, alpha ); +#! true +IsOne( + PreCompose( SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), SimplifySourceAndRange_IsoToInputSource( alpha, infinity ) ) +); +#! true +IsOne( + PreCompose( SimplifySourceAndRange_IsoFromInputRange( alpha, infinity ), SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ) +); +#! true +pi2 := PreCompose( + SimplifySource_IsoFromInputObject( alpha, infinity ), + SimplifySource( alpha, infinity ) +);; +IsCongruentForMorphisms( pi2, alpha ); +#! true +IsOne( PreCompose( SimplifySource_IsoFromInputObject( alpha, infinity ), SimplifySource_IsoToInputObject( alpha, infinity ) ) ); +#! true +pi3 := PreCompose( + SimplifyRange( alpha, infinity ), + SimplifyRange_IsoToInputObject( alpha, infinity ) +);; +IsCongruentForMorphisms( pi3, alpha ); +#! true +IsOne( PreCompose( SimplifyRange_IsoFromInputObject( alpha, infinity ), SimplifyRange_IsoToInputObject( alpha, infinity ) ) ); +#! true +#! @EndExample + diff --git a/FreydCategoriesForCAP/examples/generate_documentation.g b/AdditiveClosuresForCAP/examples/generate_documentation.g similarity index 90% rename from FreydCategoriesForCAP/examples/generate_documentation.g rename to AdditiveClosuresForCAP/examples/generate_documentation.g index 3aeaff32bd..d54b31d56b 100644 --- a/FreydCategoriesForCAP/examples/generate_documentation.g +++ b/AdditiveClosuresForCAP/examples/generate_documentation.g @@ -4,7 +4,7 @@ #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true QQ := HomalgFieldOfRationalsInSingular( );; @@ -19,7 +19,7 @@ CAP_INTERNAL_GENERATE_DOCUMENTATION_FOR_CATEGORY_INSTANCES( [ CategoryOfRows( QQxy ), "CategoryOfRows of a commutative ring", 1 ], [ CategoryOfRows( QQ ), "CategoryOfRows of a field", 3 ], ], - "FreydCategoriesForCAP", + "AdditiveClosuresForCAP", "CategoryOfRows.autogen.gd", "Category of rows", "Supported CAP operations" diff --git a/FreydCategoriesForCAP/gap/AdditiveClosure.gd b/AdditiveClosuresForCAP/gap/AdditiveClosure.gd similarity index 99% rename from FreydCategoriesForCAP/gap/AdditiveClosure.gd rename to AdditiveClosuresForCAP/gap/AdditiveClosure.gd index 34eb8c6ce3..8fb7b054d2 100644 --- a/FreydCategoriesForCAP/gap/AdditiveClosure.gd +++ b/AdditiveClosuresForCAP/gap/AdditiveClosure.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/AdditiveClosure.gi b/AdditiveClosuresForCAP/gap/AdditiveClosure.gi similarity index 99% rename from FreydCategoriesForCAP/gap/AdditiveClosure.gi rename to AdditiveClosuresForCAP/gap/AdditiveClosure.gi index 1f4d79ad46..1c170f46e6 100644 --- a/FreydCategoriesForCAP/gap/AdditiveClosure.gi +++ b/AdditiveClosuresForCAP/gap/AdditiveClosure.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/AdditiveClosuresForCAP/gap/AdditiveClosureDerivedMethods.gi b/AdditiveClosuresForCAP/gap/AdditiveClosureDerivedMethods.gi new file mode 100644 index 0000000000..01e54fd92e --- /dev/null +++ b/AdditiveClosuresForCAP/gap/AdditiveClosureDerivedMethods.gi @@ -0,0 +1,649 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Implementations +# + +## Derivations for basic operations with existing WithGiven + +## +AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProduct, + "ProjectionInSecondFactorOfWeakBiFiberProduct using ProjectionInFirstFactorOfWeakBiFiberProduct and Lift", + [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], + [ Lift, 1 ], + [ PreCompose, 1 ] ], + + function( cat, alpha, beta ) + local first_projection; + + first_projection := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + return Lift( cat, PreCompose( cat, first_projection, alpha ), beta ); + +end ); + +## +AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProduct, + "ProjectionInFirstFactorOfWeakBiFiberProduct using ProjectionInSecondFactorOfWeakBiFiberProduct and Lift", + [ [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], + [ Lift, 1 ], + [ PreCompose, 1 ] ], + + function( cat, alpha, beta ) + local second_projection; + + second_projection := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + return Lift( cat, PreCompose( cat, second_projection, beta ), alpha ); + +end ); + +## +AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushout, + "InjectionOfSecondCofactorOfWeakBiPushout using InjectionOfFirstCofactorOfWeakBiPushout and Colift", + [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], + [ Colift, 1 ], + [ PreCompose, 1 ] ], + + function( cat, alpha, beta ) + local first_injection; + + first_injection := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); + + return Colift( cat, beta, PreCompose( cat, alpha, first_injection ) ); + +end ); + +## +AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushout, + "InjectionOfFirstCofactorOfWeakBiPushout using InjectionOfSecondCofactorOfWeakBiPushout and Colift", + [ [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], + [ Colift, 1 ], + [ PreCompose, 1 ] ], + + function( cat, alpha, beta ) + local second_injection; + + second_injection := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); + + return Colift( cat, alpha, PreCompose( cat, beta, second_injection ) ); + +end ); + +## +AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProduct, + "UniversalMorphismIntoWeakBiFiberProduct using Lift", + [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], + [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], + [ Lift, 1 ], + [ UniversalMorphismIntoDirectSum, 2 ] ], + + function( cat, alpha, beta, test_mor_1, test_mor_2 ) + local projection_1, projection_2; + + projection_1 := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + projection_2 := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + return Lift( cat, UniversalMorphismIntoDirectSum( cat, [ test_mor_1, test_mor_2 ] ), + UniversalMorphismIntoDirectSum( cat, [ projection_1, projection_2 ] ) ); + +end ); + +## +AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProduct, + "UniversalMorphismIntoBiasedWeakFiberProduct using Lift", + [ [ Lift, 1 ], + [ ProjectionOfBiasedWeakFiberProduct, 1 ] ], + + function( cat, alpha, beta, test_mor ) + + return Lift( cat, + test_mor, + ProjectionOfBiasedWeakFiberProduct( cat, alpha, beta ) ); + +end ); + + +## +AddDerivationToCAP( UniversalMorphismFromWeakBiPushout, + "UniversalMorphismFromWeakBiPushout using Colift", + [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], + [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], + [ Colift, 1 ], + [ UniversalMorphismFromDirectSum, 2 ] ], + + function( cat, alpha, beta, test_mor_1, test_mor_2 ) + local injection_1, injection_2; + + injection_1 := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); + + injection_2 := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); + + return Colift( cat, UniversalMorphismFromDirectSum( cat, [ injection_1, injection_2 ] ), + UniversalMorphismFromDirectSum( cat, [ test_mor_1, test_mor_2 ] ) ); + +end ); + +## +AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushout, + "UniversalMorphismFromBiasedWeakPushout using Colift", + [ [ Colift, 1 ], + [ InjectionOfBiasedWeakPushout, 1 ] ], + + function( cat, alpha, beta, test_mor ) + + return Colift( cat, + InjectionOfBiasedWeakPushout( cat, alpha, beta ), + test_mor ); + +end ); + +## +AddDerivationToCAP( WeakKernelLift, + "WeakKernelLift as Lift of WeakKernelEmbedding", + [ [ Lift, 1 ], + [ WeakKernelEmbedding, 1 ] ], + + function( cat, mor, test_mor ) + + return Lift( cat, test_mor, WeakKernelEmbedding( cat, mor ) ); + +end ); + +## +AddDerivationToCAP( WeakCokernelColift, + "WeakCokernelColift as Colift of WeakCokernelProjection", + [ [ Colift, 1 ], + [ WeakCokernelProjection, 1 ] ], + + function( cat, mor, test_mor ) + + return Colift( cat, WeakCokernelProjection( cat, mor ), test_mor ); + +end ); + + +## Derivations for basic operations without existing WithGiven +## +AddDerivationToCAP( WeakKernelObject, + "WeakKernelObject as the source of WeakKernelEmbedding", + [ [ WeakKernelEmbedding, 1 ] ], + + function( cat, mor ) + + return Source( WeakKernelEmbedding( cat, mor ) ); + +end ); + +## +AddDerivationToCAP( WeakCokernelObject, + "WeakCokernelObject as the range of WeakCokernelProjection", + [ [ WeakCokernelProjection, 1 ] ], + + function( cat, mor ) + + return Range( WeakCokernelProjection( cat, mor ) ); + +end ); + +## +AddDerivationToCAP( WeakBiFiberProduct, + "WeakBiFiberProduct as the source of ProjectionInFirstFactorOfWeakBiFiberProduct", + [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ] ], + + function( cat, alpha, beta ) + + return Source( ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ) ); + +end ); + +## +AddDerivationToCAP( WeakBiFiberProduct, + "WeakBiFiberProduct as the source of ProjectionInSecondFactorOfWeakBiFiberProduct", + [ [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ] ], + + function( cat, alpha, beta ) + + return Source( ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ) ); + +end ); + +## +AddDerivationToCAP( BiasedWeakFiberProduct, + "BiasedWeakFiberProduct as the source of ProjectionOfBiasedWeakFiberProduct", + [ [ ProjectionOfBiasedWeakFiberProduct, 1 ] ], + + function( cat, alpha, beta ) + + return Source( ProjectionOfBiasedWeakFiberProduct( cat, alpha, beta ) ); + +end ); + + +## +AddDerivationToCAP( WeakBiPushout, + "WeakBiPushout as the range of InjectionOfFirstCofactorOfWeakBiPushout", + [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ] ], + + function( cat, alpha, beta ) + + return Range( InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ) ); + +end ); + +## +AddDerivationToCAP( WeakBiPushout, + "WeakBiPushout as the range of InjectionOfSecondCofactorOfWeakBiPushout", + [ [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ] ], + + function( cat, alpha, beta ) + + return Range( InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ) ); + +end ); + +## +AddDerivationToCAP( BiasedWeakPushout, + "BiasedWeakPushout as the range of InjectionOfBiasedWeakPushout", + [ [ InjectionOfBiasedWeakPushout, 1 ] ], + + function( cat, alpha, beta ) + + return Range( InjectionOfBiasedWeakPushout( cat, alpha, beta ) ); + +end ); + + +## abelian derivations + +## +AddDerivationToCAP( IsMonomorphism, + "IsMonomorphism by deciding whether WeakKernelEmbedding is zero", + [ [ IsZeroForMorphisms, 1 ], + [ WeakKernelEmbedding, 1 ] ], + + function( cat, alpha ) + + return IsZeroForMorphisms( cat, WeakKernelEmbedding( cat, alpha ) ); + +end ); + +## +AddDerivationToCAP( IsEpimorphism, + "IsEpimorphism by deciding whether WeakCokernelProjection is zero", + [ [ IsZeroForMorphisms, 1 ], + [ WeakCokernelProjection, 1 ] ], + + function( cat, alpha ) + + return IsZeroForMorphisms( cat, WeakCokernelProjection( cat, alpha ) ); + +end ); + +## +AddDerivationToCAP( WeakBiFiberProductMorphismToDirectSum, + "WeakBiFiberProductMorphismToDirectSum using UniversalMorphismIntoDirectSum of the two weak bi-fiber product projections", + [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], + [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], + [ UniversalMorphismIntoDirectSum, 1 ] ], + + function( cat, alpha, beta ) + local projection_1, projection_2; + + projection_1 := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + projection_2 := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); + + return UniversalMorphismIntoDirectSum( cat, [ projection_1, projection_2 ] ); + +end ); + +## +AddDerivationToCAP( DirectSumMorphismToWeakBiPushout, + "DirectSumMorphismToWeakBiPushout using UniversalMorphismFromDirectSum of the two weak bi-pushout injections", + [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], + [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], + [ UniversalMorphismFromDirectSum, 1 ] ], + + function( cat, alpha, beta ) + local injection_1, injection_2; + + injection_1 := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); + + injection_2 := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); + + return UniversalMorphismFromDirectSum( cat, [ injection_1, injection_2 ] ); + +end ); + +## +AddDerivationToCAP( WeakBiFiberProduct, + "WeakBiFiberProduct as the source of WeakBiFiberProductMorphismToDirectSum", + [ [ WeakBiFiberProductMorphismToDirectSum, 1 ] ], + + function( cat, alpha, beta ) + + return Source( WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ) ); + +end ); + +## +AddDerivationToCAP( WeakBiPushout, + "WeakBiPushout as the range of DirectSumMorphismToWeakBiPushout", + [ [ DirectSumMorphismToWeakBiPushout, 1 ] ], + + function( cat, alpha, beta ) + + return Range( DirectSumMorphismToWeakBiPushout( cat, alpha, beta ) ); + +end ); + +## Final derivations + +## +AddFinalDerivationBundle( "weak kernel using kernel", + [ [ KernelObject, 1 ], + [ KernelEmbedding, 1 ], + [ KernelLift, 1 ] ], + + [ WeakKernelObject, + WeakKernelEmbedding, + WeakKernelLift ], +[ + WeakKernelObject, + [ [ KernelObject, 1 ] ], + function( cat, morphism ) + + return KernelObject( cat, morphism ); + + end +], +[ + WeakKernelEmbedding, + [ [ KernelEmbedding, 1 ] ], + function( cat, morphism ) + + return KernelEmbedding( cat, morphism ); + + end +], +[ + WeakKernelLift, + [ [ KernelLift, 1 ] ], + function( cat, morphism, test_mor ) + + return KernelLift( cat, morphism, test_mor ); + + end +] ); + +## +AddFinalDerivationBundle( "weak cokernel using cokernel", + [ [ CokernelObject, 1 ], + [ CokernelProjection, 1 ], + [ CokernelColift, 1 ] ], + + [ WeakCokernelObject, + WeakCokernelProjection, + WeakCokernelColift ], +[ + WeakCokernelObject, + [ [ CokernelObject, 1 ] ], + function( cat, morphism ) + + return CokernelObject( cat, morphism ); + + end +], +[ + WeakCokernelProjection, + [ [ CokernelProjection, 1 ] ], + function( cat, morphism ) + + return CokernelProjection( cat, morphism ); + + end +], +[ + WeakCokernelColift, + [ [ CokernelColift, 1 ] ], + function( cat, morphism, test_mor ) + + return CokernelColift( cat, morphism, test_mor ); + + end +] ); + +## Final derivation for weak fiber products and weak pushouts. +## Decision: we use a derivation from weak kernels and direct sums + +## +AddFinalDerivationBundle( "WeakBiFiberProductMorphismToDirectSum via WeakKernelEmbedding and direct sum", + [ [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakKernelEmbedding, 1 ], + [ ProjectionInFactorOfDirectSum, 1 ], + [ UniversalMorphismIntoDirectSum, 1 ], + [ WeakKernelLift, 1 ], + ], + [ + WeakBiFiberProduct, + ProjectionInFirstFactorOfWeakBiFiberProduct, + ProjectionInSecondFactorOfWeakBiFiberProduct, + UniversalMorphismIntoWeakBiFiberProduct, + WeakBiFiberProductMorphismToDirectSum, + ], +[ + WeakBiFiberProductMorphismToDirectSum, + [ [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakKernelEmbedding, 1 ] ], + function( cat, alpha, beta ) + local direct_sum_diagram, direct_sum, proj1_alpha, proj2_beta, difference; + + direct_sum_diagram := [ Source( alpha ), Source( beta ) ]; + + direct_sum := DirectSum( cat, direct_sum_diagram ); + + proj1_alpha := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ), alpha ); + + proj2_beta := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ), beta ); + + difference := SubtractionForMorphisms( cat, proj1_alpha, proj2_beta ); + + return WeakKernelEmbedding( cat, difference ); + + end +], +[ + ProjectionInFirstFactorOfWeakBiFiberProduct, + [ [ WeakBiFiberProductMorphismToDirectSum, 1 ], + [ PreCompose, 1 ], + [ ProjectionInFactorOfDirectSum, 1 ] ], + function( cat, alpha, beta ) + local morphism_to_direct_sum; + + morphism_to_direct_sum := WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ); + + return PreCompose( cat, morphism_to_direct_sum, ProjectionInFactorOfDirectSum( cat, [ Source( alpha ), Source( beta ) ], 1 ) ); + + end +], +[ + ProjectionInSecondFactorOfWeakBiFiberProduct, + [ [ WeakBiFiberProductMorphismToDirectSum, 1 ], + [ PreCompose, 1 ], + [ ProjectionInFactorOfDirectSum, 1 ] ], + function( cat, alpha, beta ) + local morphism_to_direct_sum; + + morphism_to_direct_sum := WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ); + + return PreCompose( cat, morphism_to_direct_sum, ProjectionInFactorOfDirectSum( cat, [ Source( alpha ), Source( beta ) ], 2 ) ); + + end +], +[ + UniversalMorphismIntoWeakBiFiberProduct, + [ [ UniversalMorphismIntoDirectSum, 1 ], + [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakKernelLift, 1 ] ], + function( cat, alpha, beta, test_mor_1, test_mor_2 ) + local test_mor, direct_sum_diagram, direct_sum, proj1_alpha, proj2_beta, difference; + + test_mor := UniversalMorphismIntoDirectSum( cat, [ test_mor_1, test_mor_2 ] ); + + direct_sum_diagram := [ Source( alpha ), Source( beta ) ]; + + direct_sum := DirectSum( cat, direct_sum_diagram ); + + proj1_alpha := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ), alpha ); + + proj2_beta := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ), beta ); + + difference := SubtractionForMorphisms( cat, proj1_alpha, proj2_beta ); + + return WeakKernelLift( cat, difference, test_mor ); + + end +] ); + +## weak bi-pushout +## +AddFinalDerivationBundle( "DirectSumMorphismToWeakBiPushout via WeakCokernelProjection and direct sum", + [ [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakCokernelProjection, 1 ], + [ InjectionOfCofactorOfDirectSum, 1 ], + [ UniversalMorphismFromDirectSum, 1 ], + [ WeakCokernelColift, 1 ], + ], + [ + WeakBiPushout, + InjectionOfFirstCofactorOfWeakBiPushout, + InjectionOfSecondCofactorOfWeakBiPushout, + UniversalMorphismFromWeakBiPushout, + DirectSumMorphismToWeakBiPushout, + ], +[ + DirectSumMorphismToWeakBiPushout, + [ [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakCokernelProjection, 1 ] ], + function( cat, alpha, beta ) + local direct_sum_diagram, direct_sum, alpha_inj1, beta_inj2, difference; + + direct_sum_diagram := [ Range( alpha ), Range( beta ) ]; + + direct_sum := DirectSum( cat, direct_sum_diagram ); + + alpha_inj1 := PreCompose( cat, alpha, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ) ); + + beta_inj2 := PreCompose( cat, beta, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ) ); + + difference := SubtractionForMorphisms( cat, alpha_inj1, beta_inj2 ); + + return WeakCokernelProjection( cat, difference ); + +end +], +[ + InjectionOfFirstCofactorOfWeakBiPushout, + [ [ DirectSumMorphismToWeakBiPushout, 1 ], + [ PreCompose, 1 ], + [ InjectionOfCofactorOfDirectSum, 1 ] ], + function( cat, alpha, beta ) + local direct_sum_morphism; + + direct_sum_morphism := DirectSumMorphismToWeakBiPushout( cat, alpha, beta ); + + return PreCompose( cat, InjectionOfCofactorOfDirectSum( cat, [ Range( alpha ), Range( beta ) ], 1 ), direct_sum_morphism ); + + end +], +[ + InjectionOfSecondCofactorOfWeakBiPushout, + [ [ DirectSumMorphismToWeakBiPushout, 1 ], + [ PreCompose, 1 ], + [ InjectionOfCofactorOfDirectSum, 1 ] ], + function( cat, alpha, beta ) + local direct_sum_morphism; + + direct_sum_morphism := DirectSumMorphismToWeakBiPushout( cat, alpha, beta ); + + return PreCompose( cat, InjectionOfCofactorOfDirectSum( cat, [ Range( alpha ), Range( beta ) ], 2 ), direct_sum_morphism ); + + end +], +[ + UniversalMorphismFromWeakBiPushout, + [ [ UniversalMorphismFromDirectSum, 1 ], + [ DirectSum, 1 ], + [ PreCompose, 2 ], + [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], + [ SubtractionForMorphisms, 1 ], + [ WeakCokernelColift, 1 ] ], + function( cat, alpha, beta, test_mor_1, test_mor_2 ) + local test_mor, direct_sum_diagram, direct_sum, alpha_inj1, beta_inj2, difference; + + test_mor := UniversalMorphismFromDirectSum( cat, [ test_mor_1, test_mor_2 ] ); + + direct_sum_diagram := [ Range( alpha ), Range( beta ) ]; + + direct_sum := DirectSum( cat, direct_sum_diagram ); + + alpha_inj1 := PreCompose( cat, alpha, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ) ); + + beta_inj2 := PreCompose( cat, beta, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ) ); + + difference := SubtractionForMorphisms( cat, alpha_inj1, beta_inj2 ); + + return WeakCokernelColift( cat, difference, test_mor ); + + end +] ); + +## Final derivation for biased weak fiber products and biased weak pushouts. +## Decision: we use a derivation from weak fiber products and weak pushouts + +## +AddFinalDerivation( ProjectionOfBiasedWeakFiberProduct, + "ProjectionOfBiasedWeakFiberProduct using ProjectionInFirstFactorOfWeakBiFiberProduct", + [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ] ], + [ + BiasedWeakFiberProduct, + ProjectionOfBiasedWeakFiberProduct, + ], + + function( cat, alpha, beta ) + + return ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); + +end ); + +## +AddFinalDerivation( InjectionOfBiasedWeakPushout, + "ProjectioInjectionOfBiasedWeakPushoutnOfBiasedWeakFiberProduct using InjectionOfFirstCofactorOfWeakBiPushout", + [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ] ], + [ + BiasedWeakPushout, + InjectionOfBiasedWeakPushout, + ], + + function( cat, alpha, beta ) + + return InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); + +end ); diff --git a/AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gd b/AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gd new file mode 100644 index 0000000000..8bd5704a2c --- /dev/null +++ b/AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gd @@ -0,0 +1,570 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Declarations +# +#! @Chapter Basic operations + +DeclareGlobalVariable( "ADDITIVE_CLOSURE_METHOD_NAME_RECORD" ); + +DeclareGlobalFunction( "WEAK_BI_FIBER_PRODUCT_PREFUNCTION" ); + +DeclareGlobalFunction( "UNIVERSAL_MORPHISM_INTO_WEAK_BI_FIBER_PRODUCT_PREFUNCTION" ); + +DeclareGlobalFunction( "WEAK_BI_PUSHOUT_PREFUNCTION" ); + +DeclareGlobalFunction( "UNIVERSAL_MORPHISM_FROM_WEAK_BI_PUSHOUT_PREFUNCTION" ); + +DeclareGlobalFunction( "UNIVERSAL_MORPHISM_INTO_BIASED_WEAK_FIBER_PRODUCT_PREFUNCTION" ); + +DeclareGlobalFunction( "UNIVERSAL_MORPHISM_FROM_BIASED_WEAK_PUSHOUT_PREFUNCTION" ); + +##TODO: Adjust documentation + +#################################### +## +#! @Section Weak kernel +## +#################################### + +#! For a given morphism $\alpha: A \rightarrow B$, a weak kernel of $\alpha$ consists of three parts: +#! * an object $K$, +#! * a morphism $\iota: K \rightarrow A$ such that $\alpha \circ \iota \sim_{K,B} 0$, +#! * a dependent function $u$ mapping each morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$ to a morphism $u(\tau): T \rightarrow K$ such that $\iota \circ u( \tau ) \sim_{T,A} \tau$. +#! The triple $( K, \iota, u )$ is called a weak kernel of $\alpha$. +#! We denote the object $K$ of such a triple by $\mathrm{WeakKernelObject}(\alpha)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the weak kernel. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (T) at (-\w,\w) {$T$}; +#! \node (K) at (-\w,0) {$K$}; +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (K) to node[pos=0.45, above] {$\iota$} (A); +#! \draw[-latex] (T) to node[pos=0.45, above right] {$\tau$} (A); +#! \draw[-latex] (T) to node[pos=0.45, left] {$\exists u( \tau )$} (K); +#! \draw[-latex, dotted] (T) to [out = 0, in = 90] node[pos=0.45, above right] {$\alpha \circ \tau \sim_{T,B} 0$} (B); +#! \draw[-latex, dotted] (K) to [out = -45, in = -135] node[pos=0.45, below] {$\alpha \circ \iota \sim_{K,B} 0$} (B); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + +## Main Operations and Attributes +#! @Description +#! The argument is a morphism $\alpha$. +#! The output is the weak kernel $K$ of $\alpha$. +#! @Returns an object +#! @Arguments alpha +DeclareAttribute( "WeakKernelObject", + IsCapCategoryMorphism ); + +#! @Description +#! The argument is a morphism $\alpha: A \rightarrow B$. +#! The output is the weak kernel embedding $\iota: \mathrm{WeakKernelObject}(\alpha) \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}(\mathrm{WeakKernelObject}(\alpha),A)$ +#! @Arguments alpha +DeclareAttribute( "WeakKernelEmbedding", + IsCapCategoryMorphism ); + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$ +#! and an object $K = \mathrm{WeakKernelObject}(\alpha)$. +#! The output is the weak kernel embedding $\iota: K \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}(K,A)$ +#! @Arguments alpha, K +DeclareOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", + [ IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$ +#! and a test morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$. +#! The output is the morphism $u(\tau): T \rightarrow \mathrm{WeakKernelObject}(\alpha)$ +#! given by the universal property of the weak kernel. +#! @Returns a morphism in $\mathrm{Hom}(T,\mathrm{WeakKernelObject}(\alpha))$ +#! @Arguments alpha, tau +DeclareOperation( "WeakKernelLift", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$, +#! a test morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$, +#! and an object $K = \mathrm{WeakKernelObject}(\alpha)$. +#! The output is the morphism $u(\tau): T \rightarrow K$ +#! given by the universal property of the weak kernel. +#! @Returns a morphism in $\mathrm{Hom}(T,K)$ +#! @Arguments alpha, tau, K +DeclareOperation( "WeakKernelLiftWithGivenWeakKernelObject", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#################################### +## +#! @Section Weak cokernel +## +#################################### + +#! For a given morphism $\alpha: A \rightarrow B$, a weak cokernel of $\alpha$ consists of three parts: +#! * an object $K$, +#! * a morphism $\epsilon: B \rightarrow K$ such that $\epsilon \circ \alpha \sim_{A,K} 0$, +#! * a dependent function $u$ mapping each $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$ to a morphism $u(\tau):K \rightarrow T$ such that $u(\tau) \circ \epsilon \sim_{B,T} \tau$. +#! The triple $( K, \epsilon, u )$ is called a weak cokernel of $\alpha$. +#! We denote the object $K$ of such a triple by $\mathrm{WeakCokernelObject}(\alpha)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the weak cokernel. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \node (K) at (2*\w,0) {$K$}; +#! \node (T) at (2*\w,\w) {$T$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (B) to node[pos=0.45, above] {$\epsilon$} (K); +#! \draw[-latex] (B) to node[pos=0.45, above left] {$\tau$} (T); +#! \draw[-latex] (K) to node[pos=0.45, right] {$\exists u( \tau )$} (T); +#! \draw[-latex, dotted] (A) to [out = 90, in = 180] node[pos=0.45, above left] {$\tau \circ \alpha \sim_{A,T} 0$} (T); +#! \draw[-latex, dotted] (A) to [out = -45, in = -135] node[pos=0.45, below] {$\epsilon \circ \alpha \sim_{A,K} 0$} (K); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + + +## Main Operations and Attributes +#! @Description +#! The argument is a morphism $\alpha: A \rightarrow B$. +#! The output is the weak cokernel $K$ of $\alpha$. +#! @Returns an object +#! @Arguments alpha +DeclareAttribute( "WeakCokernelObject", + IsCapCategoryMorphism ); + +#! @Description +#! The argument is a morphism $\alpha: A \rightarrow B$. +#! The output is the weak cokernel projection $\epsilon: B \rightarrow \mathrm{WeakCokernelObject}( \alpha )$. +#! @Returns a morphism in $\mathrm{Hom}(B, \mathrm{WeakCokernelObject}( \alpha ))$ +#! @Arguments alpha +DeclareAttribute( "WeakCokernelProjection", + IsCapCategoryMorphism ); + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$ +#! and an object $K = \mathrm{WeakCokernelObject}(\alpha)$. +#! The output is the weak cokernel projection $\epsilon: B \rightarrow \mathrm{WeakCokernelObject}( \alpha )$. +#! @Returns a morphism in $\mathrm{Hom}(B, K)$ +#! @Arguments alpha, K +DeclareOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", + [ IsCapCategoryMorphism, IsCapCategoryObject ] ); + + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$ +#! and a test morphism $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$. +#! The output is the morphism $u(\tau): \mathrm{WeakCokernelObject}(\alpha) \rightarrow T$ +#! given by the universal property of the weak cokernel. +#! @Returns a morphism in $\mathrm{Hom}(\mathrm{WeakCokernelObject}(\alpha),T)$ +#! @Arguments alpha, tau +DeclareOperation( "WeakCokernelColift", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are a morphism $\alpha: A \rightarrow B$, +#! a test morphism $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$, +#! and an object $K = \mathrm{WeakCokernelObject}(\alpha)$. +#! The output is the morphism $u(\tau): K \rightarrow T$ +#! given by the universal property of the weak cokernel. +#! @Returns a morphism in $\mathrm{Hom}(K,T)$ +#! @Arguments alpha, tau, K +DeclareOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#################################### +## +#! @Section Weak bi-fiber product +## +#################################### + +#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon C \rightarrow B)$, a weak bi-fiber product of $(\alpha, \beta)$ consists of three parts: +#! * an object $P$, +#! * morphisms $\pi_1: P \rightarrow A$, $\pi_2: P \rightarrow B$ such that $\alpha \circ \pi_1 \sim_{P,B} \beta \circ \pi_2$, +#! * a dependent function $u$ mapping each pair $\tau = ( \tau_1, \tau_2 )$ of morphisms $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$ with the property $\alpha \circ \tau_1 \sim_{T,B} \beta \circ \tau_2$ to a morphism $u(\tau):T \rightarrow P$ such that $\pi_1 \circ u( \tau ) \sim_{A,T} \tau_1$ and $\pi_2 \circ u( \tau ) \sim_{C,T} \tau_2$. +#! The quadrupel $( P, \pi_1, \pi_2, u )$ is called a weak bi-fiber product of $(\alpha,\beta)$. +#! We denote the object $P$ of such a quadrupel by $\mathrm{WeakBiFiberProduct}(\alpha,\beta)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the weak bi-fiber product. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \node (C) at (\w,\w) {$C$}; +#! \node (P) at (0,\w) {$P$}; +#! \node (T) at (-\w,2*\w) {$T$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (C) to node[pos=0.45, right] {$\beta$} (B); +#! \draw[-latex] (P) to node[pos=0.45, left] {$\pi_1$} (A); +#! \draw[-latex] (P) to node[pos=0.45, above] {$\pi_2$} (C); +#! \draw[-latex] (T) to [out = -90, in = 180] node[pos=0.45, left] {$\tau_1$} (A); +#! \draw[-latex] (T) to [out = 0, in = 90] node[pos=0.45, above] {$\tau_2$} (C); +#! \draw[-latex] (T) to node[pos=0.45, above right] {$\exists u( \tau )$} (P); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + +## Main Operations and Attributes + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the weak bi-fiber product $P$ of $\alpha$ and $\beta$. +#! @Returns an object +#! @Arguments alpha, beta +DeclareOperation( "WeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the first weak bi-fiber product projection $\pi_1: P \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}( P, A )$ +#! @Arguments alpha, beta +DeclareOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$ +#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. +#! The output is the first weak bi-fiber product projection $\pi_1: P \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}( P, A )$ +#! @Arguments alpha, beta, P +DeclareOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the second weak bi-fiber product projection $\pi_2: P \rightarrow C$. +#! @Returns a morphism in $\mathrm{Hom}( P, C )$ +#! @Arguments alpha, beta +DeclareOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$ +#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. +#! The output is the second weak bi-fiber product projection $\pi_2: P \rightarrow C$. +#! @Returns a morphism in $\mathrm{Hom}( P, C )$ +#! @Arguments alpha, beta, P +DeclareOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, +#! $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-fiber product +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( T, P )$ +#! @Arguments alpha, beta, tau_1, tau_2 +DeclareOperation( "UniversalMorphismIntoWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, +#! $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$ +#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-fiber product +#! $P$. +#! @Returns a morphism in $\mathrm{Hom}( T, P )$ +#! @Arguments alpha, beta, tau_1, tau_2, P +DeclareOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the morphism $P \rightarrow A \oplus C$ obtained +#! from the two weak bi-fiber product projections $\pi_1$ and $\pi_2$ and +#! the universal property of the direct sum. +#! @Returns a morphism in $\mathrm{Hom}( P, A \oplus C )$ +#! @Arguments alpha, beta +DeclareOperation( "WeakBiFiberProductMorphismToDirectSum", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#################################### +## +#! @Section Biased weak fiber product +## +#################################### + +#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon C \rightarrow B)$, a biased weak fiber product of $(\alpha, \beta)$ consists of three parts: +#! * an object $P$, +#! * a morphism $\pi: P \rightarrow A$ such that there exists a morphism $\delta: P \rightarrow C$ such that $\beta \circ \delta \sim_{P,B} \alpha \circ \pi$, +#! * a dependent function $u$ mapping each $\tau: T \rightarrow A$, which admits a morphism $\mu \colon T \rightarrow C$ with $\beta \circ \mu \sim_{T,B} \alpha \circ \tau$, to a morphism $u(\tau):T \rightarrow P$ such that $\pi \circ u(\tau) \sim_{T,A} \tau$. +#! The triple $( P, \pi, u )$ is called a biased weak fiber product of $(\alpha,\beta)$. +#! We denote the object $P$ of such a triple by $\mathrm{BiasedWeakFiberProduct}(\alpha,\beta)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the biased weak fiber product. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \node (C) at (\w,\w) {$C$}; +#! \node (P) at (0,\w) {$P$}; +#! \node (T) at (-\w,2*\w) {$T$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (C) to node[pos=0.45, right] {$\beta$} (B); +#! \draw[-latex] (P) to node[pos=0.45, left] {$\pi$} (A); +#! \draw[-latex] (T) to [out = -90, in = 180] node[pos=0.45, left] {$\tau$} (A); +#! \draw[-latex] (T) to node[pos=0.45, above right] {$\exists u( \tau )$} (P); +#! \draw[-latex, dotted] (P) to node[pos=0.45, above] {$\delta$} (C); +#! \draw[-latex, dotted] (T) to [out = 0, in = 90] node[pos=0.45, above] {$\mu$} (C); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + + +## Main Operations and Attributes + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the biased weak fiber product $P$ of $\alpha$ and $\beta$. +#! @Returns an object +#! @Arguments alpha, beta +DeclareOperation( "BiasedWeakFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +## corresponds to projection in 1st factor +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the biased weak fiber product projection $\pi: P \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}( P, A )$ +#! @Arguments alpha, beta +DeclareOperation( "ProjectionOfBiasedWeakFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, +#! and an object $P = \mathrm{BiasedWeakFiberProduct}( \alpha, \beta )$. +#! The output is the biased weak fiber product projection $\pi: P \rightarrow A$. +#! @Returns a morphism in $\mathrm{Hom}( P, A )$ +#! @Arguments alpha, beta, P +DeclareOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, +#! $\tau: T \rightarrow A$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak fiber product +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( T, P )$ +#! @Arguments alpha, beta, tau +DeclareOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, +#! $\tau: T \rightarrow A$ +#! and an object $P = \mathrm{BiasedWeakFiberProduct}( \alpha, \beta )$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak fiber product +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( T, P )$ +#! @Arguments alpha, beta, tau, P +DeclareOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#################################### +## +#! @Section Weak bi-pushout +## +#################################### + +#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon A \rightarrow C)$, a weak bi-pushout of $(\alpha, \beta)$ consists of three parts: +#! * an object $P$, +#! * morphisms $\iota_1: B \rightarrow P$, $\iota_2: C \rightarrow P$ such that $\iota_1 \circ \alpha \sim_{A,P} \iota_2 \circ \beta$, +#! * a dependent function $u$ mapping each pair $\tau = (\tau_1, \tau_2)$ of morphisms $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$ with the property $\tau_1 \circ \alpha \sim_{A,T} \tau_2 \circ \beta$ to a morphism $u(\tau): P \rightarrow T$ such that $u( \tau ) \circ \iota_1 \sim_{B,T} \tau_1$ and $u( \tau ) \circ \iota_2 \sim_{C,T} \tau_2$. +#! The quadrupel $( P, \iota_1, \iota_2, u )$ is called a weak bi-pushout of $(\alpha,\beta)$. +#! We denote the object $P$ of such a quadrupel by $\mathrm{WeakBiPushout}(\alpha,\beta)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the weak bi-pushout. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \node (C) at (0,\w) {$C$}; +#! \node (P) at (\w,\w) {$P$}; +#! \node (T) at (2*\w,2*\w) {$T$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (A) to node[pos=0.45, left] {$\beta$} (C); +#! \draw[-latex] (B) to node[pos=0.45, right] {$\iota_1$} (P); +#! \draw[-latex] (B) to [out = 0, in = -90] node[pos=0.45, right] {$\tau_1$} (T); +#! \draw[-latex] (P) to node[pos=0.45, above left] {$\exists u( \tau )$} (T); +#! \draw[-latex] (C) to node[pos=0.45, above] {$\iota_2$} (P); +#! \draw[-latex] (C) to [out = 90, in = 180] node[pos=0.45, above] {$\tau_2$} (T); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. +#! The output is the weak bi-pushout $P$ of $\alpha$ and $\beta$. +#! @Returns an object +#! @Arguments alpha, beta +DeclareOperation( "WeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. +#! The output is the first weak bi-pushout injection $\iota_1: B \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( B, P )$ +#! @Arguments alpha, beta +DeclareOperation( "InjectionOfFirstCofactorOfWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. +#! The output is the second weak bi-pushout injection $\iota_2: C \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( C, P )$ +#! @Arguments alpha, beta +DeclareOperation( "InjectionOfSecondCofactorOfWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ +#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. +#! The output is the first weak bi-pushout injection $\iota_1: B \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( B, P )$ +#! @Arguments alpha, beta, P +DeclareOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ +#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. +#! The output is the second weak bi-pushout injection $\iota_2: C \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( C, P )$ +#! @Arguments alpha, beta, P +DeclareOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, +#! $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-pushout +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( P, T )$ +#! @Arguments alpha, beta, tau_1, tau_2 +DeclareOperation( "UniversalMorphismFromWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, +#! $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$, +#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-pushout +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( P, T )$ +#! @Arguments alpha, beta, tau_1, tau_2, P +DeclareOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. +#! The output is the morphism $B \oplus C \rightarrow P$ obtained +#! from the two weak bi-fiber product injections $\iota_1$ and $\iota_2$ and +#! the universal property of the direct sum. +#! @Returns a morphism in $\mathrm{Hom}(B \oplus C, P )$ +#! @Arguments alpha, beta +DeclareOperation( "DirectSumMorphismToWeakBiPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#################################### +## +#! @Section Biased weak pushout +## +#################################### + +#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta: A \rightarrow C)$, a biased weak pushout of $(\alpha, \beta)$ consists of three parts: +#! * an object $P$, +#! * a morphism $\iota: B \rightarrow P$ such that there exists a morphism $\delta: C \rightarrow P$ such that $\delta \circ \beta \sim_{A,P} \iota \circ \alpha$, +#! * a dependent function $u$ mapping each $\tau: B \rightarrow T$, which admits a morphism $\mu \colon C \rightarrow T$ with $\mu \circ \beta \sim_{B,T} \tau \circ \alpha$, to a morphism $u(\tau):P \rightarrow T$ such that $u(\tau) \circ \iota \sim_{A,T} \tau$. +#! The triple $( P, \iota, u )$ is called a biased weak pushout of $(\alpha,\beta)$. +#! We denote the object $P$ of such a triple by $\mathrm{BiasedWeakPushout}(\alpha,\beta)$. +#! We say that the morphism $u(\tau)$ is induced by the +#! universal property of the biased weak pushout. + +#! @BeginLatexOnly +#! \begin{center} +#! \begin{tikzpicture} +#! \def\w{2} +#! \node (A) at (0,0) {$A$}; +#! \node (B) at (\w,0) {$B$}; +#! \node (C) at (0,\w) {$C$}; +#! \node (P) at (\w,\w) {$P$}; +#! \node (T) at (2*\w,2*\w) {$T$}; +#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); +#! \draw[-latex] (A) to node[pos=0.45, left] {$\beta$} (C); +#! \draw[-latex] (B) to node[pos=0.45, right] {$\iota$} (P); +#! \draw[-latex] (B) to [out = 0, in = -90] node[pos=0.45, right] {$\tau$} (T); +#! \draw[-latex] (P) to node[pos=0.45, above left] {$\exists u( \tau )$} (T); +#! \draw[-latex, dotted] (C) to node[pos=0.45, above] {$\delta$} (P); +#! \draw[-latex, dotted] (C) to [out = 90, in = 180] node[pos=0.45, above] {$\mu$} (T); +#! \end{tikzpicture} +#! \end{center} +#! @EndLatexOnly + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. +#! The output is the biased weak pushout $P$ of $\alpha$ and $\beta$. +#! @Returns an object +#! @Arguments alpha, beta +DeclareOperation( "BiasedWeakPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. +#! The output is the biased weak pushout injection $\iota: B \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( B, P )$ +#! @Arguments alpha, beta +DeclareOperation( "InjectionOfBiasedWeakPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ +#! and an object $P = \mathrm{BiasedWeakPushout}( \alpha, \beta )$. +#! The output is the biased weak pushout injection $\iota: B \rightarrow P$. +#! @Returns a morphism in $\mathrm{Hom}( B, P )$ +#! @Arguments alpha, beta, P +DeclareOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + +#! @Description +#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, +#! $\tau: B \rightarrow T$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak pushout +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( P, T )$ +#! @Arguments alpha, beta, tau +DeclareOperation( "UniversalMorphismFromBiasedWeakPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); + +#! @Description +#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, +#! $\tau: B \rightarrow T$ +#! and an object $P = \mathrm{BiasedWeakPushout}( \alpha, \beta )$. +#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak pushout +#! $P$ of $\alpha$ and $\beta$. +#! @Returns a morphism in $\mathrm{Hom}( P, T )$ +#! @Arguments alpha, beta, tau, P +DeclareOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); + diff --git a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi b/AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gi similarity index 82% rename from FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi rename to AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gi index 6b39f58dd2..93c874dd95 100644 --- a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi +++ b/AdditiveClosuresForCAP/gap/AdditiveClosureMethodRecord.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # @@ -99,9 +99,7 @@ InstallGlobalFunction( UNIVERSAL_MORPHISM_FROM_BIASED_WEAK_PUSHOUT_PREFUNCTION, end ); -InstallValue( FREYD_CATEGORIES_METHOD_NAME_RECORD, rec( - -## Basic operations for Freyd categories +InstallValue( ADDITIVE_CLOSURE_METHOD_NAME_RECORD, rec( ## Weak kernels @@ -485,125 +483,18 @@ UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout := rec( return_type := "morphism", is_merely_set_theoretic := true ), -## an abelian construction -SomeProjectiveObjectForKernelObject := rec( - filter_list := [ "category", "morphism" ], - return_type := "object", - dual_operation := "SomeInjectiveObjectForCokernelObject", - is_merely_set_theoretic := true ), - -EpimorphismFromSomeProjectiveObjectForKernelObject := rec( - filter_list := [ "category", "morphism" ], - input_arguments_names := [ "cat", "alpha" ], - with_given_object_position := "Source", - output_range_getter_string := "KernelObject( cat, alpha )", - output_range_getter_preconditions := [ [ "KernelObject", 1 ] ], - return_type := "morphism", - dual_operation := "MonomorphismToSomeInjectiveObjectForCokernelObject", - is_merely_set_theoretic := true ), - -EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject := rec( - filter_list := [ "category", "morphism", "object" ], - input_arguments_names := [ "cat", "alpha", "source" ], - return_type := "morphism", - output_source_getter_string := "source", - output_range_getter_string := "KernelObject( cat, alpha )", - output_range_getter_preconditions := [ [ "KernelObject", 1 ] ], - dual_operation := "MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject", - is_merely_set_theoretic := true ), - -SomeInjectiveObjectForCokernelObject := rec( - filter_list := [ "category", "morphism" ], - return_type := "object", - dual_operation := "SomeProjectiveObjectForKernelObject", - is_merely_set_theoretic := true ), - -MonomorphismToSomeInjectiveObjectForCokernelObject := rec( - filter_list := [ "category", "morphism" ], - input_arguments_names := [ "cat", "alpha" ], - output_source_getter_string := "CokernelObject( cat, alpha )", - output_source_getter_preconditions := [ [ "CokernelObject", 1 ] ], - with_given_object_position := "Range", - return_type := "morphism", - dual_operation := "EpimorphismFromSomeProjectiveObjectForKernelObject", - is_merely_set_theoretic := true ), - -MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject := rec( - filter_list := [ "category", "morphism", "object" ], - input_arguments_names := [ "cat", "alpha", "range" ], - return_type := "morphism", - output_source_getter_string := "CokernelObject( cat, alpha )", - output_source_getter_preconditions := [ [ "CokernelObject", 1 ] ], - output_range_getter_string := "range", - dual_operation := "EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject", - is_merely_set_theoretic := true ), - ) ); -CAP_INTERNAL_ENHANCE_NAME_RECORD( FREYD_CATEGORIES_METHOD_NAME_RECORD ); +CAP_INTERNAL_ENHANCE_NAME_RECORD( ADDITIVE_CLOSURE_METHOD_NAME_RECORD ); CAP_INTERNAL_GENERATE_DECLARATIONS_AND_INSTALLATIONS_FROM_METHOD_NAME_RECORD( - FREYD_CATEGORIES_METHOD_NAME_RECORD, - "FreydCategoriesForCAP", + ADDITIVE_CLOSURE_METHOD_NAME_RECORD, + "AdditiveClosuresForCAP", "MethodRecord", "Add Functions", "Available Add functions" ); -CAP_INTERNAL_REGISTER_METHOD_NAME_RECORD_OF_PACKAGE( FREYD_CATEGORIES_METHOD_NAME_RECORD, "FreydCategoriesForCAP" ); +CAP_INTERNAL_REGISTER_METHOD_NAME_RECORD_OF_PACKAGE( ADDITIVE_CLOSURE_METHOD_NAME_RECORD, "AdditiveClosuresForCAP" ); -CAP_INTERNAL_INSTALL_ADDS_FROM_RECORD( FREYD_CATEGORIES_METHOD_NAME_RECORD ); - -#################################### -## -## Free abelian category -## -#################################### - -InstallMethod( AsMorphismInFreeAbelianCategory, - [ IsCapCategoryMorphism ], - - function( morphism ) - - return Opposite( - AsFreydCategoryMorphism( - Opposite( - AsFreydCategoryMorphism( - AsAdditiveClosureMorphism( morphism ) - ) - ) - ) - ); - -end ); - -################################### -## -## Finitely presented functors -## -#################################### - -## -InstallMethod( CovariantExtAsFreydCategoryObject, - [ IsCapCategoryObject, IsInt ], - - function( object, i ) - local morphism, j; - - if i = 0 then - - return AsFreydCategoryObject( Opposite( object ) ); - - fi; - - morphism := EpimorphismFromSomeProjectiveObject( object ); - - for j in [ 2 .. i ] do - - morphism := EpimorphismFromSomeProjectiveObjectForKernelObject( morphism ); - - od; - - return FreydCategoryObject( Opposite( KernelEmbedding( morphism ) ) ); - -end ); +CAP_INTERNAL_INSTALL_ADDS_FROM_RECORD( ADDITIVE_CLOSURE_METHOD_NAME_RECORD ); diff --git a/FreydCategoriesForCAP/gap/CategoryOfColumns.gd b/AdditiveClosuresForCAP/gap/CategoryOfColumns.gd similarity index 97% rename from FreydCategoriesForCAP/gap/CategoryOfColumns.gd rename to AdditiveClosuresForCAP/gap/CategoryOfColumns.gd index fd18303dcb..519c8735b5 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfColumns.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfColumns.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfColumns.gi b/AdditiveClosuresForCAP/gap/CategoryOfColumns.gi similarity index 92% rename from FreydCategoriesForCAP/gap/CategoryOfColumns.gi rename to AdditiveClosuresForCAP/gap/CategoryOfColumns.gi index c195bf3a1d..327c91cd30 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfColumns.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfColumns.gi @@ -1,14 +1,14 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # # read precompiled categories -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi" ); #################################### ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd b/AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd similarity index 82% rename from FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd rename to AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd index 054ec9dcfb..305b7f49d2 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi b/AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi similarity index 98% rename from FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi rename to AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi index 63ccc536a6..891d8fd8c4 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd similarity index 97% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd index 50e73703d6..64cbdd047e 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi index 228a197388..84aba5c31a 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd similarity index 97% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd index 085ee6e461..f78f8a86b9 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi index efed496fef..f6f29307a2 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd index c501ef0f0d..7e7c62fc1d 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi index dfb310c137..66b1de2a0e 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd similarity index 98% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd index 347adb9b0a..1256c5d830 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi index 2c5be59d58..741e0c2759 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/ToDo.txt b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/ToDo.txt similarity index 100% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/ToDo.txt rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/ToDo.txt diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd index 02e092a386..da0c12d40c 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gd @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi rename to AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi index c1c4dba4a5..12ec573f8a 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfGradedRowsAndColumns/Tools.gi @@ -1,6 +1,6 @@ ############################################################################# ## -## FreydCategoriesForCAP package +## AdditiveClosuresForCAP package ## ## Copyright 2019, Martin Bies, ULB Brussels ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows.autogen.gd b/AdditiveClosuresForCAP/gap/CategoryOfRows.autogen.gd similarity index 90% rename from FreydCategoriesForCAP/gap/CategoryOfRows.autogen.gd rename to AdditiveClosuresForCAP/gap/CategoryOfRows.autogen.gd index b9cee55dfd..644c446da2 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows.autogen.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows.autogen.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # @@ -15,8 +15,8 @@ #! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * #! * @@ -32,21 +32,21 @@ #! * #! * #! * -#! * +#! * #! * #! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * #! * #! * -#! * -#! * -#! * -#! * +#! * +#! * +#! * +#! * #! * #! * #! * @@ -107,12 +107,12 @@ #! * #! * #! * -#! * -#! * -#! * -#! * -#! * -#! * +#! * +#! * +#! * +#! * +#! * +#! * #! * #! * #! * @@ -143,43 +143,43 @@ #! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * #! * #! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * #! * #! * #! * #! * -#! * -#! * +#! * +#! * #! * #! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * -#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * +#! * #! * #! * #! * diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows.gd b/AdditiveClosuresForCAP/gap/CategoryOfRows.gd similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfRows.gd rename to AdditiveClosuresForCAP/gap/CategoryOfRows.gd index 79b26d61b0..12b4cf5ac7 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows.gi b/AdditiveClosuresForCAP/gap/CategoryOfRows.gi similarity index 98% rename from FreydCategoriesForCAP/gap/CategoryOfRows.gi rename to AdditiveClosuresForCAP/gap/CategoryOfRows.gi index 3670a257ba..db369fd6f2 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows.gi @@ -1,14 +1,14 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # # read precompiled categories -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi" ); #################################### ## diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd similarity index 89% rename from FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd rename to AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd index b58b432ffb..e26d0717a2 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi rename to AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi index ec1c5161e7..21013926bc 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi similarity index 99% rename from FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi rename to AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi index 376f3a3576..528fbfba9a 100644 --- a/FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi +++ b/AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/AdditiveClosuresForCAP/gap/MethodRecordDeclarations.autogen.gd b/AdditiveClosuresForCAP/gap/MethodRecordDeclarations.autogen.gd new file mode 100644 index 0000000000..0771219d02 --- /dev/null +++ b/AdditiveClosuresForCAP/gap/MethodRecordDeclarations.autogen.gd @@ -0,0 +1,694 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Declarations +# +# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi + +#! @Chapter Add Functions + +#! @Section Available Add functions + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `BiasedWeakFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2, arg3 ) \mapsto \mathtt{BiasedWeakFiberProduct}(arg2, arg3)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `BiasedWeakPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2, arg3 ) \mapsto \mathtt{BiasedWeakPushout}(arg2, arg3)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddBiasedWeakPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddBiasedWeakPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `DirectSumMorphismToWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, beta ) \mapsto \mathtt{DirectSumMorphismToWeakBiPushout}(alpha, beta)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddDirectSumMorphismToWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddDirectSumMorphismToWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfBiasedWeakPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{InjectionOfBiasedWeakPushout}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfBiasedWeakPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfBiasedWeakPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfFirstCofactorOfWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{InjectionOfFirstCofactorOfWeakBiPushout}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfSecondCofactorOfWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{InjectionOfSecondCofactorOfWeakBiPushout}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionInFirstFactorOfWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{ProjectionInFirstFactorOfWeakBiFiberProduct}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionInSecondFactorOfWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{ProjectionInSecondFactorOfWeakBiFiberProduct}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionOfBiasedWeakFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b ) \mapsto \mathtt{ProjectionOfBiasedWeakFiberProduct}(a, b)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionOfBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionOfBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct}(a, b, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismFromBiasedWeakPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t ) \mapsto \mathtt{UniversalMorphismFromBiasedWeakPushout}(a, b, t)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, P ) \mapsto \mathtt{UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout}(a, b, t, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismFromWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, s ) \mapsto \mathtt{UniversalMorphismFromWeakBiPushout}(a, b, t, s)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismFromWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismFromWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, s, P ) \mapsto \mathtt{UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout}(a, b, t, s, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismIntoBiasedWeakFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t ) \mapsto \mathtt{UniversalMorphismIntoBiasedWeakFiberProduct}(a, b, t)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, P ) \mapsto \mathtt{UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct}(a, b, t, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismIntoWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, s ) \mapsto \mathtt{UniversalMorphismIntoWeakBiFiberProduct}(a, b, t, s)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( a, b, t, s, P ) \mapsto \mathtt{UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, t, s, P)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakBiFiberProduct`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2, arg3 ) \mapsto \mathtt{WeakBiFiberProduct}(arg2, arg3)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakBiFiberProduct", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakBiFiberProduct", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakBiFiberProductMorphismToDirectSum`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, beta ) \mapsto \mathtt{WeakBiFiberProductMorphismToDirectSum}(alpha, beta)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakBiFiberProductMorphismToDirectSum", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakBiFiberProductMorphismToDirectSum", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakBiPushout`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2, arg3 ) \mapsto \mathtt{WeakBiPushout}(arg2, arg3)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakBiPushout", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakBiPushout", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakCokernelColift`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, tau ) \mapsto \mathtt{WeakCokernelColift}(alpha, tau)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakCokernelColift", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakCokernelColift", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakCokernelColiftWithGivenWeakCokernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, tau, K ) \mapsto \mathtt{WeakCokernelColiftWithGivenWeakCokernelObject}(alpha, tau, K)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakCokernelColiftWithGivenWeakCokernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakCokernelColiftWithGivenWeakCokernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakCokernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2 ) \mapsto \mathtt{WeakCokernelObject}(arg2)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakCokernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakCokernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakCokernelProjection`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha ) \mapsto \mathtt{WeakCokernelProjection}(alpha)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakCokernelProjection", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakCokernelProjection", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakCokernelProjectionWithGivenWeakCokernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, K ) \mapsto \mathtt{WeakCokernelProjectionWithGivenWeakCokernelObject}(alpha, K)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakCokernelProjectionWithGivenWeakCokernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakCokernelProjectionWithGivenWeakCokernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakKernelEmbedding`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha ) \mapsto \mathtt{WeakKernelEmbedding}(alpha)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakKernelEmbedding", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakKernelEmbedding", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakKernelEmbeddingWithGivenWeakKernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, K ) \mapsto \mathtt{WeakKernelEmbeddingWithGivenWeakKernelObject}(alpha, K)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakKernelEmbeddingWithGivenWeakKernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakKernelEmbeddingWithGivenWeakKernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakKernelLift`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, tau ) \mapsto \mathtt{WeakKernelLift}(alpha, tau)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakKernelLift", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakKernelLift", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakKernelLiftWithGivenWeakKernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( alpha, tau, K ) \mapsto \mathtt{WeakKernelLiftWithGivenWeakKernelObject}(alpha, tau, K)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakKernelLiftWithGivenWeakKernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakKernelLiftWithGivenWeakKernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + + +#! @BeginGroup +#! @Description +#! The arguments are a category $C$ and a function $F$. +#! This operation adds the given function $F$ +#! to the category for the basic operation `WeakKernelObject`. +#! Optionally, a weight (default: 100) can be specified which should roughly correspond +#! to the computational complexity of the function (lower weight = less complex = faster execution). +#! $F: ( arg2 ) \mapsto \mathtt{WeakKernelObject}(arg2)$. +#! @Returns nothing +#! @Arguments C, F +DeclareOperation( "AddWeakKernelObject", + [ IsCapCategory, IsFunction ] ); + +#! @Arguments C, F, weight +DeclareOperation( "AddWeakKernelObject", + [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup + diff --git a/AdditiveClosuresForCAP/gap/MethodRecordInstallations.autogen.gi b/AdditiveClosuresForCAP/gap/MethodRecordInstallations.autogen.gi new file mode 100644 index 0000000000..377647a789 --- /dev/null +++ b/AdditiveClosuresForCAP/gap/MethodRecordInstallations.autogen.gi @@ -0,0 +1,1228 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Implementations +# +# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi + +## BiasedWeakFiberProduct +InstallMethod( AddBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "BiasedWeakFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "BiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## BiasedWeakPushout +InstallMethod( AddBiasedWeakPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "BiasedWeakPushout", category, func, -1 ); + +end ); + +InstallMethod( AddBiasedWeakPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "BiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## DirectSumMorphismToWeakBiPushout +InstallMethod( AddDirectSumMorphismToWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "DirectSumMorphismToWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddDirectSumMorphismToWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "DirectSumMorphismToWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InjectionOfBiasedWeakPushout +InstallMethod( AddInjectionOfBiasedWeakPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfBiasedWeakPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfBiasedWeakPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout +InstallMethod( AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, + "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout by calling InjectionOfBiasedWeakPushout with the WithGiven argument(s) dropped", + [ + [ InjectionOfBiasedWeakPushout, 1 ], + ], + function( cat, a, b, P ) + + return InjectionOfBiasedWeakPushout( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( InjectionOfBiasedWeakPushout, + "InjectionOfBiasedWeakPushout by calling InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout with the WithGiven object(s)", + [ + [ InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, 1 ], + [ BiasedWeakPushout, 1 ], + ], + function( cat, a, b ) + + return InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout( cat, a, b, BiasedWeakPushout( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## InjectionOfFirstCofactorOfWeakBiPushout +InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout +InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout by calling InjectionOfFirstCofactorOfWeakBiPushout with the WithGiven argument(s) dropped", + [ + [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], + ], + function( cat, a, b, P ) + + return InjectionOfFirstCofactorOfWeakBiPushout( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushout, + "InjectionOfFirstCofactorOfWeakBiPushout by calling InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", + [ + [ InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, 1 ], + [ WeakBiPushout, 1 ], + ], + function( cat, a, b ) + + return InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, WeakBiPushout( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## InjectionOfSecondCofactorOfWeakBiPushout +InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout +InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, + "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout by calling InjectionOfSecondCofactorOfWeakBiPushout with the WithGiven argument(s) dropped", + [ + [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], + ], + function( cat, a, b, P ) + + return InjectionOfSecondCofactorOfWeakBiPushout( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushout, + "InjectionOfSecondCofactorOfWeakBiPushout by calling InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", + [ + [ InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, 1 ], + [ WeakBiPushout, 1 ], + ], + function( cat, a, b ) + + return InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, WeakBiPushout( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## ProjectionInFirstFactorOfWeakBiFiberProduct +InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct +InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct by calling ProjectionInFirstFactorOfWeakBiFiberProduct with the WithGiven argument(s) dropped", + [ + [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], + ], + function( cat, a, b, P ) + + return ProjectionInFirstFactorOfWeakBiFiberProduct( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProduct, + "ProjectionInFirstFactorOfWeakBiFiberProduct by calling ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", + [ + [ ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], + [ WeakBiFiberProduct, 1 ], + ], + function( cat, a, b ) + + return ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, WeakBiFiberProduct( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## ProjectionInSecondFactorOfWeakBiFiberProduct +InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct +InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, + "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct by calling ProjectionInSecondFactorOfWeakBiFiberProduct with the WithGiven argument(s) dropped", + [ + [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], + ], + function( cat, a, b, P ) + + return ProjectionInSecondFactorOfWeakBiFiberProduct( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProduct, + "ProjectionInSecondFactorOfWeakBiFiberProduct by calling ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", + [ + [ ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], + [ WeakBiFiberProduct, 1 ], + ], + function( cat, a, b ) + + return ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, WeakBiFiberProduct( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## ProjectionOfBiasedWeakFiberProduct +InstallMethod( AddProjectionOfBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionOfBiasedWeakFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionOfBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionOfBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct +InstallMethod( AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct by calling ProjectionOfBiasedWeakFiberProduct with the WithGiven argument(s) dropped", + [ + [ ProjectionOfBiasedWeakFiberProduct, 1 ], + ], + function( cat, a, b, P ) + + return ProjectionOfBiasedWeakFiberProduct( cat, a, b ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( ProjectionOfBiasedWeakFiberProduct, + "ProjectionOfBiasedWeakFiberProduct by calling ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct with the WithGiven object(s)", + [ + [ ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, 1 ], + [ BiasedWeakFiberProduct, 1 ], + ], + function( cat, a, b ) + + return ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct( cat, a, b, BiasedWeakFiberProduct( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## UniversalMorphismFromBiasedWeakPushout +InstallMethod( AddUniversalMorphismFromBiasedWeakPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismFromBiasedWeakPushout", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismFromBiasedWeakPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismFromBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout +InstallMethod( AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, + "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout by calling UniversalMorphismFromBiasedWeakPushout with the WithGiven argument(s) dropped", + [ + [ UniversalMorphismFromBiasedWeakPushout, 1 ], + ], + function( cat, a, b, t, P ) + + return UniversalMorphismFromBiasedWeakPushout( cat, a, b, t ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushout, + "UniversalMorphismFromBiasedWeakPushout by calling UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout with the WithGiven object(s)", + [ + [ UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, 1 ], + [ BiasedWeakPushout, 1 ], + ], + function( cat, a, b, t ) + + return UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout( cat, a, b, t, BiasedWeakPushout( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## UniversalMorphismFromWeakBiPushout +InstallMethod( AddUniversalMorphismFromWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismFromWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismFromWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismFromWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout +InstallMethod( AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, + "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout by calling UniversalMorphismFromWeakBiPushout with the WithGiven argument(s) dropped", + [ + [ UniversalMorphismFromWeakBiPushout, 1 ], + ], + function( cat, a, b, t, s, P ) + + return UniversalMorphismFromWeakBiPushout( cat, a, b, t, s ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( UniversalMorphismFromWeakBiPushout, + "UniversalMorphismFromWeakBiPushout by calling UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", + [ + [ UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, 1 ], + [ WeakBiPushout, 1 ], + ], + function( cat, a, b, t, s ) + + return UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, t, s, WeakBiPushout( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## UniversalMorphismIntoBiasedWeakFiberProduct +InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct +InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, + "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct by calling UniversalMorphismIntoBiasedWeakFiberProduct with the WithGiven argument(s) dropped", + [ + [ UniversalMorphismIntoBiasedWeakFiberProduct, 1 ], + ], + function( cat, a, b, t, P ) + + return UniversalMorphismIntoBiasedWeakFiberProduct( cat, a, b, t ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProduct, + "UniversalMorphismIntoBiasedWeakFiberProduct by calling UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct with the WithGiven object(s)", + [ + [ UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, 1 ], + [ BiasedWeakFiberProduct, 1 ], + ], + function( cat, a, b, t ) + + return UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct( cat, a, b, t, BiasedWeakFiberProduct( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## UniversalMorphismIntoWeakBiFiberProduct +InstallMethod( AddUniversalMorphismIntoWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismIntoWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismIntoWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismIntoWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct +InstallMethod( AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, + "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct by calling UniversalMorphismIntoWeakBiFiberProduct with the WithGiven argument(s) dropped", + [ + [ UniversalMorphismIntoWeakBiFiberProduct, 1 ], + ], + function( cat, a, b, t, s, P ) + + return UniversalMorphismIntoWeakBiFiberProduct( cat, a, b, t, s ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProduct, + "UniversalMorphismIntoWeakBiFiberProduct by calling UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", + [ + [ UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], + [ WeakBiFiberProduct, 1 ], + ], + function( cat, a, b, t, s ) + + return UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, t, s, WeakBiFiberProduct( cat, a, b ) ); + +end : is_with_given_derivation := true ); + +## WeakBiFiberProduct +InstallMethod( AddWeakBiFiberProduct, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakBiFiberProduct", category, func, -1 ); + +end ); + +InstallMethod( AddWeakBiFiberProduct, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakBiFiberProductMorphismToDirectSum +InstallMethod( AddWeakBiFiberProductMorphismToDirectSum, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakBiFiberProductMorphismToDirectSum", category, func, -1 ); + +end ); + +InstallMethod( AddWeakBiFiberProductMorphismToDirectSum, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakBiFiberProductMorphismToDirectSum", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakBiPushout +InstallMethod( AddWeakBiPushout, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakBiPushout", category, func, -1 ); + +end ); + +InstallMethod( AddWeakBiPushout, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakCokernelColift +InstallMethod( AddWeakCokernelColift, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakCokernelColift", category, func, -1 ); + +end ); + +InstallMethod( AddWeakCokernelColift, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakCokernelColift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakCokernelColiftWithGivenWeakCokernelObject +InstallMethod( AddWeakCokernelColiftWithGivenWeakCokernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakCokernelColiftWithGivenWeakCokernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( WeakCokernelColiftWithGivenWeakCokernelObject, + "WeakCokernelColiftWithGivenWeakCokernelObject by calling WeakCokernelColift with the WithGiven argument(s) dropped", + [ + [ WeakCokernelColift, 1 ], + ], + function( cat, alpha, tau, K ) + + return WeakCokernelColift( cat, alpha, tau ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( WeakCokernelColift, + "WeakCokernelColift by calling WeakCokernelColiftWithGivenWeakCokernelObject with the WithGiven object(s)", + [ + [ WeakCokernelColiftWithGivenWeakCokernelObject, 1 ], + [ WeakCokernelObject, 1 ], + ], + function( cat, alpha, tau ) + + return WeakCokernelColiftWithGivenWeakCokernelObject( cat, alpha, tau, WeakCokernelObject( cat, alpha ) ); + +end : is_with_given_derivation := true ); + +## WeakCokernelObject +InstallMethod( AddWeakCokernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakCokernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakCokernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakCokernelProjection +InstallMethod( AddWeakCokernelProjection, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakCokernelProjection", category, func, -1 ); + +end ); + +InstallMethod( AddWeakCokernelProjection, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakCokernelProjection", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakCokernelProjectionWithGivenWeakCokernelObject +InstallMethod( AddWeakCokernelProjectionWithGivenWeakCokernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakCokernelProjectionWithGivenWeakCokernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( WeakCokernelProjectionWithGivenWeakCokernelObject, + "WeakCokernelProjectionWithGivenWeakCokernelObject by calling WeakCokernelProjection with the WithGiven argument(s) dropped", + [ + [ WeakCokernelProjection, 1 ], + ], + function( cat, alpha, K ) + + return WeakCokernelProjection( cat, alpha ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( WeakCokernelProjection, + "WeakCokernelProjection by calling WeakCokernelProjectionWithGivenWeakCokernelObject with the WithGiven object(s)", + [ + [ WeakCokernelProjectionWithGivenWeakCokernelObject, 1 ], + [ WeakCokernelObject, 1 ], + ], + function( cat, alpha ) + + return WeakCokernelProjectionWithGivenWeakCokernelObject( cat, alpha, WeakCokernelObject( cat, alpha ) ); + +end : is_with_given_derivation := true ); + +## WeakKernelEmbedding +InstallMethod( AddWeakKernelEmbedding, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakKernelEmbedding", category, func, -1 ); + +end ); + +InstallMethod( AddWeakKernelEmbedding, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakKernelEmbedding", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakKernelEmbeddingWithGivenWeakKernelObject +InstallMethod( AddWeakKernelEmbeddingWithGivenWeakKernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakKernelEmbeddingWithGivenWeakKernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( WeakKernelEmbeddingWithGivenWeakKernelObject, + "WeakKernelEmbeddingWithGivenWeakKernelObject by calling WeakKernelEmbedding with the WithGiven argument(s) dropped", + [ + [ WeakKernelEmbedding, 1 ], + ], + function( cat, alpha, K ) + + return WeakKernelEmbedding( cat, alpha ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( WeakKernelEmbedding, + "WeakKernelEmbedding by calling WeakKernelEmbeddingWithGivenWeakKernelObject with the WithGiven object(s)", + [ + [ WeakKernelEmbeddingWithGivenWeakKernelObject, 1 ], + [ WeakKernelObject, 1 ], + ], + function( cat, alpha ) + + return WeakKernelEmbeddingWithGivenWeakKernelObject( cat, alpha, WeakKernelObject( cat, alpha ) ); + +end : is_with_given_derivation := true ); + +## WeakKernelLift +InstallMethod( AddWeakKernelLift, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakKernelLift", category, func, -1 ); + +end ); + +InstallMethod( AddWeakKernelLift, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakKernelLift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WeakKernelLiftWithGivenWeakKernelObject +InstallMethod( AddWeakKernelLiftWithGivenWeakKernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakKernelLiftWithGivenWeakKernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakKernelLiftWithGivenWeakKernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakKernelLiftWithGivenWeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( WeakKernelLiftWithGivenWeakKernelObject, + "WeakKernelLiftWithGivenWeakKernelObject by calling WeakKernelLift with the WithGiven argument(s) dropped", + [ + [ WeakKernelLift, 1 ], + ], + function( cat, alpha, tau, K ) + + return WeakKernelLift( cat, alpha, tau ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( WeakKernelLift, + "WeakKernelLift by calling WeakKernelLiftWithGivenWeakKernelObject with the WithGiven object(s)", + [ + [ WeakKernelLiftWithGivenWeakKernelObject, 1 ], + [ WeakKernelObject, 1 ], + ], + function( cat, alpha, tau ) + + return WeakKernelLiftWithGivenWeakKernelObject( cat, alpha, tau, WeakKernelObject( cat, alpha ) ); + +end : is_with_given_derivation := true ); + +## WeakKernelObject +InstallMethod( AddWeakKernelObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WeakKernelObject", category, func, -1 ); + +end ); + +InstallMethod( AddWeakKernelObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); diff --git a/FreydCategoriesForCAP/gap/RingsAsAbCats.gd b/AdditiveClosuresForCAP/gap/RingsAsAbCats.gd similarity index 98% rename from FreydCategoriesForCAP/gap/RingsAsAbCats.gd rename to AdditiveClosuresForCAP/gap/RingsAsAbCats.gd index 2b5bef8a52..59d876c02a 100644 --- a/FreydCategoriesForCAP/gap/RingsAsAbCats.gd +++ b/AdditiveClosuresForCAP/gap/RingsAsAbCats.gd @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Declarations # diff --git a/FreydCategoriesForCAP/gap/RingsAsAbCats.gi b/AdditiveClosuresForCAP/gap/RingsAsAbCats.gi similarity index 99% rename from FreydCategoriesForCAP/gap/RingsAsAbCats.gi rename to AdditiveClosuresForCAP/gap/RingsAsAbCats.gi index 283eb3af63..ae7524c982 100644 --- a/FreydCategoriesForCAP/gap/RingsAsAbCats.gi +++ b/AdditiveClosuresForCAP/gap/RingsAsAbCats.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi index 6956595cda..d80429e3f6 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_ArbitraryRing_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi index 8a44228820..e6020ca9aa 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_CommutativeRing_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi index 96aa0abb10..33b18c864d 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_Field_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi index 58b683fa9a..f8036e5031 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfColumns_as_Opposite_CategoryOfRows_HomalgExteriorRingOverField_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi index 6d712f3fd5..d488964b91 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_ArbitraryRing_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi index 951f0a4bfd..e3b693b5e7 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CommutativeRing_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi index 43ce4481af..e84459d16e 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_Field_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi similarity index 99% rename from FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi rename to AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi index 2810dc4254..0e481018fb 100644 --- a/FreydCategoriesForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi +++ b/AdditiveClosuresForCAP/gap/precompiled_categories/CategoryOfRows_as_AdditiveClosure_RingAsCategory_HomalgExteriorRingOverField_precompiled.gi @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories # # Implementations # diff --git a/AdditiveClosuresForCAP/init.g b/AdditiveClosuresForCAP/init.g new file mode 100644 index 0000000000..1bf11fde35 --- /dev/null +++ b/AdditiveClosuresForCAP/init.g @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Reading the declaration part of the package. +# + +ReadPackage( "AdditiveClosuresForCAP", "gap/MethodRecordDeclarations.autogen.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/AdditiveClosureMethodRecord.gd" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfColumns.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd" ); + +# include the packages for graded rows and columns +#= comment for Julia +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/Tools.gd" ); +# =# + +ReadPackage( "AdditiveClosuresForCAP", "gap/AdditiveClosure.gd" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/RingsAsAbCats.gd" ); diff --git a/AdditiveClosuresForCAP/makedoc.g b/AdditiveClosuresForCAP/makedoc.g new file mode 100644 index 0000000000..2337d9a473 --- /dev/null +++ b/AdditiveClosuresForCAP/makedoc.g @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# This file is a script which compiles the package manual. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; + +AutoDoc( rec( + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/CategoryOfGradedRowsAndColumns" ], + ), + extract_examples := rec( + units := "Single", + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + \usepackage{tikz} + \usetikzlibrary{arrows} + \usetikzlibrary{calc} + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); + +QUIT; diff --git a/AdditiveClosuresForCAP/makedoc_with_overfull_hbox_warnings.g b/AdditiveClosuresForCAP/makedoc_with_overfull_hbox_warnings.g new file mode 100644 index 0000000000..84d86ee2b2 --- /dev/null +++ b/AdditiveClosuresForCAP/makedoc_with_overfull_hbox_warnings.g @@ -0,0 +1,45 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# This file is a script which compiles the package manual and prints overfull hbox warnings. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; + +AutoDoc( rec( + dir := "doc_tmp/", + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/CategoryOfGradedRowsAndColumns" ], + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + \usepackage{tikz} + \usetikzlibrary{arrows} + \usetikzlibrary{calc} + % Many thanks to https://tex.stackexchange.com/questions/22466/how-to-convince-fancyvrb-to-give-overfull-warnings/534486#534486 + \makeatletter + \def\FV@ListProcessLine#1{% + \hbox to \hsize{% + \kern\leftmargin + \hbox to \linewidth{% + \FV@LeftListNumber + \FV@LeftListFrame + \FancyVerbFormatLine{#1}\hfil % change \hss to \hfil + \FV@RightListFrame + \FV@RightListNumber}% + \hss}} + \makeatother + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); + +QUIT; diff --git a/AdditiveClosuresForCAP/makefile b/AdditiveClosuresForCAP/makefile new file mode 100644 index 0000000000..10791e47e2 --- /dev/null +++ b/AdditiveClosuresForCAP/makefile @@ -0,0 +1,57 @@ +# make sure gap --quitonbreak fails even if it is part of a pipe +SHELL=/bin/bash -o pipefail + +all: doc test + +doc: doc/manual.six + +doc/manual.six: makedoc.g \ + PackageInfo.g \ + $(wildcard doc/*.autodoc gap/*.gd gap/*.gi examples/*.g examples/*/*.g) + gap --quitonbreak makedoc.g + +clean: + (cd doc ; ./clean) + +test: doc + gap tst/testall.g + +test-basic-spacing: + # exit code 1 means no match, which is what we want here (exit code 2 signals an error) + grep -RPl "\t" examples/ gap/; test $$? -eq 1 || (echo "Tabs found" && exit 1) + grep -RPl "\r" examples/ gap/; test $$? -eq 1 || (echo "Windows line-endings found" && exit 1) + grep -RPzL "\n\z" examples/ gap/ | grep ""; test $$? -eq 1 || (echo "File with no newline at end of file found" && exit 1) + +test-doc: doc + cp -aT doc/ doc_tmp/ + cd doc_tmp && ./clean + gap --quitonbreak makedoc_with_overfull_hbox_warnings.g | perl -pe 'END { exit $$status } $$status=1 if /#W/;' + +test-with-coverage: doc + gap --quitonbreak --cover stats tst/testall.g + gap --quitonbreak --norepl -c 'LoadPackage("profiling"); OutputJsonCoverage("stats", "coverage.json");' + +test-spacing: + # exit code 1 means no match, which is what we want here (exit code 2 signals an error) + grep -R "[^ [\"] " gap/*.gi; test $$? -eq 1 || (echo "Duplicate spaces found" && exit 1) + grep -RE '[^ ] +$$' gap/*; test $$? -eq 1 || (echo "Trailing whitespace found" && exit 1) + for filename in gap/*; do \ + echo $$filename; \ + gap --quitonbreak --norepl --banner -c "LoadPackage(\"AdditiveClosuresForCAP\"); SizeScreen([4096]); func := ReadAsFunction(\"$$filename\"); FileString(\"gap_spacing\", DisplayString(func));"; \ + # In a perfect world, the DisplayString of a function would exactly match our code. However, our line breaks and indentation might differ from the GAP ones, \ + # so we remove all indentation, line breaks, and empty lines, and afterwards insert line breaks at semicolons again for better readability. \ + cat "gap_spacing" | tail -n +2 | head -n -2 | sed 's/\[ \]/[ ]/g' | sed 's/( )/( )/g' | sed 's/( :/( :/g' | sed 's/ *$$//' | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed 's/;/;\n/g' > modified_gap_spacing; \ + cat "$$filename" | grep -v "^ *[#]" | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed "s/;/;\n/g" > modified_custom_spacing; \ + # Our code might still differ from the GAP code, for example because of additional brackets. \ + # Thus, we diff the code once as expected and once ignoring all space. Diffing the two diffs then shows lines which only differ by spacing. \ + diff modified_gap_spacing modified_custom_spacing > spacing_diff; \ + diff modified_gap_spacing modified_custom_spacing --ignore-all-space --ignore-space-change --ignore-trailing-space --ignore-blank-lines > spacing_diff_no_blanks; \ + diff spacing_diff_no_blanks spacing_diff || exit; \ + done + rm gap_spacing + rm modified_gap_spacing + rm modified_custom_spacing + rm spacing_diff + rm spacing_diff_no_blanks + +ci-test: test-basic-spacing test-with-coverage diff --git a/AdditiveClosuresForCAP/read.g b/AdditiveClosuresForCAP/read.g new file mode 100644 index 0000000000..d6a34ca1f2 --- /dev/null +++ b/AdditiveClosuresForCAP/read.g @@ -0,0 +1,28 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# Reading the implementation part of the package. +# + +ReadPackage( "AdditiveClosuresForCAP", "gap/AdditiveClosureMethodRecord.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/MethodRecordInstallations.autogen.gi" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfColumns.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi" ); + +# include the packages for graded rows and columns +#= comment for Julia +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfGradedRowsAndColumns/Tools.gi" ); +# =# + +ReadPackage( "AdditiveClosuresForCAP", "gap/AdditiveClosure.gi" ); +ReadPackage( "AdditiveClosuresForCAP", "gap/AdditiveClosureDerivedMethods.gi" ); + +ReadPackage( "AdditiveClosuresForCAP", "gap/RingsAsAbCats.gi" ); diff --git a/AdditiveClosuresForCAP/tst/100_LoadPackage.tst b/AdditiveClosuresForCAP/tst/100_LoadPackage.tst new file mode 100644 index 0000000000..17b2ade976 --- /dev/null +++ b/AdditiveClosuresForCAP/tst/100_LoadPackage.tst @@ -0,0 +1,28 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# This file tests if the package can be loaded without errors or warnings. +# +# do not load suggested dependencies automatically +gap> PushOptions( rec( OnlyNeeded := true ) ); +gap> package_loading_info_level := InfoLevel( InfoPackageLoading );; +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_ERROR );; +gap> LoadPackage( "IO_ForHomalg", false ); +true +gap> LoadPackage( "RingsForHomalg", false ); +true +gap> LoadPackage( "GaussForHomalg", false ); +true +gap> LoadPackage( "AdditiveClosuresForCAP", false ); +true +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_INFO );; +gap> LoadPackage( "IO_ForHomalg" ); +true +gap> LoadPackage( "RingsForHomalg" ); +true +gap> LoadPackage( "GaussForHomalg" ); +true +gap> LoadPackage( "AdditiveClosuresForCAP" ); +true +gap> SetInfoLevel( InfoPackageLoading, package_loading_info_level );; +gap> HOMALG_IO.show_banners := false;; diff --git a/FreydCategoriesForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst b/AdditiveClosuresForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst similarity index 92% rename from FreydCategoriesForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst rename to AdditiveClosuresForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst index 6ae48f8af6..44b2d26ff2 100644 --- a/FreydCategoriesForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst +++ b/AdditiveClosuresForCAP/tst/CategoryOfRows_as_AdditiveClosure_RingAsCategory.tst @@ -1,7 +1,7 @@ gap> START_TEST( "CategoryOfRows_as_AdditiveClosure_RingAsCategory" ); # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true gap> QQ := HomalgFieldOfRationals( );; gap> vec := CategoryOfRows_as_AdditiveClosure_RingAsCategory( QQ ); @@ -119,10 +119,5 @@ gap> beta := InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMo gap> IsCongruentForMorphisms( mor, beta ); true -# make sure FreydCategory( rows ) has the same range category of hom structure as rows -# this can only be the case if FreydCategory is able to determine that the distinguished object is projective -gap> IsIdenticalObj( RangeCategoryOfHomomorphismStructure( FreydCategory( rows ) ), RangeCategoryOfHomomorphismStructure( rows ) ); -true - # gap> STOP_TEST( "CategoryOfRows_as_AdditiveClosure_RingAsCategory" ); diff --git a/FreydCategoriesForCAP/tst/ClosedAndCoclosedRows.tst b/AdditiveClosuresForCAP/tst/ClosedAndCoclosedRows.tst similarity index 99% rename from FreydCategoriesForCAP/tst/ClosedAndCoclosedRows.tst rename to AdditiveClosuresForCAP/tst/ClosedAndCoclosedRows.tst index 2b008eda30..4084d6c771 100644 --- a/FreydCategoriesForCAP/tst/ClosedAndCoclosedRows.tst +++ b/AdditiveClosuresForCAP/tst/ClosedAndCoclosedRows.tst @@ -4,7 +4,7 @@ gap> START_TEST("ClosedAndCoclosedRows.tst"); -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true gap> Q := HomalgFieldOfRationals();; diff --git a/FreydCategoriesForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst b/AdditiveClosuresForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst similarity index 99% rename from FreydCategoriesForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst rename to AdditiveClosuresForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst index c2f3d5255b..25d89d0e02 100644 --- a/FreydCategoriesForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst +++ b/AdditiveClosuresForCAP/tst/TensorCorrespondenceRowsAndOppositeOfRows.tst @@ -4,7 +4,7 @@ gap> START_TEST( "TensorCorrespondenceRowsAndOppositeOfRows.tst" ); -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true gap> Q := HomalgFieldOfRationals();; diff --git a/AdditiveClosuresForCAP/tst/testall.g b/AdditiveClosuresForCAP/tst/testall.g new file mode 100644 index 0000000000..4f54b39977 --- /dev/null +++ b/AdditiveClosuresForCAP/tst/testall.g @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AdditiveClosuresForCAP: Additive closures for pre-abelian categories +# +# This file runs package tests. It is also referenced in the package +# metadata in PackageInfo.g. +# +options := rec( + exitGAP := true, + testOptions := rec( + compareFunction := "uptowhitespace", + ), +); + +# reverse RecNames 50% of the time to detect code relying on the order of RecNames +if Random( RandomSource( IsMersenneTwister, NanosecondsSinceEpoch( ) ), [ false, true ] ) then + + Display( "Executing with reversed RecNames" ); + + MakeReadWriteGlobal( "RecNames" ); + + old_RecNames := RecNames; + + RecNames := record -> Reversed( old_RecNames( record ) ); + + MakeReadOnlyGlobal( "RecNames" ); + +else + + Display( "Executing with non-reversed RecNames" ); + +fi; + +TestDirectory( DirectoriesPackageLibrary( "AdditiveClosuresForCAP", "tst" ), options ); + +FORCE_QUIT_GAP( 1 ); # if we ever get here, there was an error diff --git a/CAP/PackageInfo.g b/CAP/PackageInfo.g index 4dfccf2b9f..8d24ceb2b3 100644 --- a/CAP/PackageInfo.g +++ b/CAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "CAP", Subtitle := "Categories, Algorithms, Programming", -Version := "2025.06-08", +Version := "2025.06-09", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", diff --git a/CAP/gap/ReinterpretationOfCategory.gd b/CAP/gap/ReinterpretationOfCategory.gd index 2f5c1fd9f9..e96e13e174 100644 --- a/CAP/gap/ReinterpretationOfCategory.gd +++ b/CAP/gap/ReinterpretationOfCategory.gd @@ -55,7 +55,7 @@ #! We reinterpret `Opposite( CategoryOfRows( R ) )` as `CategoryOfColumns( R )` using #! #! with the options described in the following (see `CategoryOfColumns_as_Opposite_CategoryOfRows.gi` in -#! `FreydCategoriesForCAP` for a full implementation). +#! `AdditiveClosuresForCAP` for a full implementation). #! #! #! Set the options `category_filter`, `category_object_filter`, and `category_morphism_filter` diff --git a/CompilerForCAP/PackageInfo.g b/CompilerForCAP/PackageInfo.g index 76298451de..632b9294d1 100644 --- a/CompilerForCAP/PackageInfo.g +++ b/CompilerForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "CompilerForCAP", Subtitle := "Speed up and verify categorical algorithms", -Version := "2025.06-01", +Version := "2025.06-02", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", diff --git a/CompilerForCAP/README.md b/CompilerForCAP/README.md index 27bc2a5d7c..a2b6b0239d 100644 --- a/CompilerForCAP/README.md +++ b/CompilerForCAP/README.md @@ -28,7 +28,7 @@ As an example, consider the category = FreydCategory( AdditiveClosure( RingAsCategory( R ) ) ).

-built from a ring using category constructors available in [FreydCategoriesForCAP](/FreydCategoriesForCAP). +built from a ring using category constructors available in [AdditiveClosuresForCAP](/AdditiveClosuresForCAP) and [FreydCategoriesForCAP](/FreydCategoriesForCAP). We can visualize a computation in this category consisting of three operations as follows: diff --git a/CompilerForCAP/benchmarks/FPres.g b/CompilerForCAP/benchmarks/FPres.g index 6381ca2c65..23703b77de 100644 --- a/CompilerForCAP/benchmarks/FPres.g +++ b/CompilerForCAP/benchmarks/FPres.g @@ -1,3 +1,4 @@ +LoadPackage( "AdditiveClosuresForCAP", false ); LoadPackage( "FreydCategoriesForCAP", false ); LoadPackage( "ModulePresentationsForCAP", false ); diff --git a/CompilerForCAP/benchmarks/algorithms.g b/CompilerForCAP/benchmarks/algorithms.g index a7f8d22c52..b5506aa63e 100644 --- a/CompilerForCAP/benchmarks/algorithms.g +++ b/CompilerForCAP/benchmarks/algorithms.g @@ -1,5 +1,5 @@ LoadPackage( "CompilerForCAP", false ); -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); star := RingAsCategoryUniqueObject( RingAsCategory( Integers ) ); diff --git a/CompilerForCAP/benchmarks/boxing.g b/CompilerForCAP/benchmarks/boxing.g index 0486a63395..660aacf91e 100644 --- a/CompilerForCAP/benchmarks/boxing.g +++ b/CompilerForCAP/benchmarks/boxing.g @@ -1,5 +1,5 @@ LoadPackage( "CompilerForCAP", false ); -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); DeactivateDefaultCaching( ); diff --git a/CompilerForCAP/benchmarks/data_structures.g b/CompilerForCAP/benchmarks/data_structures.g index 86a2ea4ca6..2589e7a993 100644 --- a/CompilerForCAP/benchmarks/data_structures.g +++ b/CompilerForCAP/benchmarks/data_structures.g @@ -1,5 +1,5 @@ LoadPackage( "CompilerForCAP", false ); -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); # simplification of data structures R := HomalgRingOfIntegers( ); diff --git a/CompilerForCAP/examples/LinearAlgebraForCAP.g b/CompilerForCAP/examples/LinearAlgebraForCAP.g index 92ac6fd0a2..5c41f055e4 100644 --- a/CompilerForCAP/examples/LinearAlgebraForCAP.g +++ b/CompilerForCAP/examples/LinearAlgebraForCAP.g @@ -4,7 +4,7 @@ #! @Example -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true LoadPackage( "LinearAlgebraForCAP", false ); #! true diff --git a/CompilerForCAP/examples/precompile_CategoryOfColumns_as_Opposite_CategoryOfRows.g b/CompilerForCAP/examples/precompile_CategoryOfColumns_as_Opposite_CategoryOfRows.g index d945207396..77ed43431e 100644 --- a/CompilerForCAP/examples/precompile_CategoryOfColumns_as_Opposite_CategoryOfRows.g +++ b/CompilerForCAP/examples/precompile_CategoryOfColumns_as_Opposite_CategoryOfRows.g @@ -6,9 +6,9 @@ #! #@if String({}->1-[1-1]) = "function ( ) return 1 - [ (1 - 1) ]; end" -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true -ReadPackage( "FreydCategoriesForCAP", +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi"); #! true @@ -27,7 +27,7 @@ precompile_CategoryOfColumns := function( homalg_ring, name ) homalg_ring ), [ homalg_ring ], - "FreydCategoriesForCAP", + "AdditiveClosuresForCAP", Concatenation( "CategoryOfColumns_as_Opposite_CategoryOfRows_", name, diff --git a/CompilerForCAP/examples/precompile_CategoryOfRows_as_AdditiveClosure_RingAsCategory.g b/CompilerForCAP/examples/precompile_CategoryOfRows_as_AdditiveClosure_RingAsCategory.g index 4dc88c2ebd..e232937532 100644 --- a/CompilerForCAP/examples/precompile_CategoryOfRows_as_AdditiveClosure_RingAsCategory.g +++ b/CompilerForCAP/examples/precompile_CategoryOfRows_as_AdditiveClosure_RingAsCategory.g @@ -6,9 +6,9 @@ #! #@if String({}->1-[1-1]) = "function ( ) return 1 - [ (1 - 1) ]; end" -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true -ReadPackage( "FreydCategoriesForCAP", +ReadPackage( "AdditiveClosuresForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory_CompilerLogic.gi"); #! true @@ -27,7 +27,7 @@ precompile_CategoryOfRows := function( homalg_ring, name ) homalg_ring ), [ homalg_ring ], - "FreydCategoriesForCAP", + "AdditiveClosuresForCAP", Concatenation( "CategoryOfRows_as_AdditiveClosure_RingAsCategory_", name, diff --git a/CompilerForCAP/examples/precompile_MatrixCategory_as_CategoryOfRows.g b/CompilerForCAP/examples/precompile_MatrixCategory_as_CategoryOfRows.g index 5ab3a2787a..321b4402ca 100644 --- a/CompilerForCAP/examples/precompile_MatrixCategory_as_CategoryOfRows.g +++ b/CompilerForCAP/examples/precompile_MatrixCategory_as_CategoryOfRows.g @@ -6,7 +6,7 @@ #! #@if String({}->1-[1-1]) = "function ( ) return 1 - [ (1 - 1) ]; end" -LoadPackage( "FreydCategoriesForCAP", false ); +LoadPackage( "AdditiveClosuresForCAP", false ); #! true LoadPackage( "LinearAlgebraForCAP", false ); #! true diff --git a/CompilerForCAP/examples/precompile_ModulePresentations_as_FreydCategory_CategoryOfRowsOrColumns.g b/CompilerForCAP/examples/precompile_ModulePresentations_as_FreydCategory_CategoryOfRowsOrColumns.g index 1389ab6d4d..604a0abcb2 100644 --- a/CompilerForCAP/examples/precompile_ModulePresentations_as_FreydCategory_CategoryOfRowsOrColumns.g +++ b/CompilerForCAP/examples/precompile_ModulePresentations_as_FreydCategory_CategoryOfRowsOrColumns.g @@ -10,6 +10,8 @@ LoadPackage( "ModulePresentationsForCAP", false ); #! true LoadPackage( "FreydCategoriesForCAP", false ); #! true +LoadPackage( "AdditiveClosuresForCAP", false ); +#! true ReadPackage( "LinearAlgebraForCAP", "gap/CompilerLogic.gi" ); #! true diff --git a/CompilerForCAP/gap/TypeSignaturesOfMatricesForHomalg.gi b/CompilerForCAP/gap/TypeSignaturesOfMatricesForHomalg.gi index 451ab1cd14..18ccb459f1 100644 --- a/CompilerForCAP/gap/TypeSignaturesOfMatricesForHomalg.gi +++ b/CompilerForCAP/gap/TypeSignaturesOfMatricesForHomalg.gi @@ -31,7 +31,7 @@ CapJitAddTypeSignature( "HomalgMatrixListList", [ IsList, IsInt, IsInt, IsHomalg ring := input_types[4].ring; Assert( 0, input_types[1].element_type.filter = IsList ); - Assert( 0, input_types[1].element_type.element_type = CapJitDataTypeOfElementOfRing( ring ) or input_types[1].element_type.element_type.filter = IsInt ); # for example, integers appear in AddZeroMorphism in FreydCategoriesForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi + Assert( 0, input_types[1].element_type.element_type = CapJitDataTypeOfElementOfRing( ring ) or input_types[1].element_type.element_type.filter = IsInt ); # for example, integers appear in AddZeroMorphism in AdditiveClosuresForCAP/gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi return rec( filter := IsHomalgMatrix, diff --git a/CompilerForCAP/tst/100_LoadPackage.tst b/CompilerForCAP/tst/100_LoadPackage.tst index 37dafaf906..a3a2acbb22 100644 --- a/CompilerForCAP/tst/100_LoadPackage.tst +++ b/CompilerForCAP/tst/100_LoadPackage.tst @@ -9,6 +9,8 @@ gap> package_loading_info_level := InfoLevel( InfoPackageLoading );; gap> SetInfoLevel( InfoPackageLoading, PACKAGE_ERROR );; gap> LoadPackage( "IO_ForHomalg", false ); true +gap> LoadPackage( "AdditiveClosuresForCAP", false ); +true gap> LoadPackage( "FreydCategoriesForCAP", false ); true gap> LoadPackage( "LinearAlgebraForCAP", false ); @@ -20,6 +22,8 @@ true gap> SetInfoLevel( InfoPackageLoading, PACKAGE_INFO );; gap> LoadPackage( "IO_ForHomalg" ); true +gap> LoadPackage( "AdditiveClosuresForCAP" ); +true gap> LoadPackage( "FreydCategoriesForCAP" ); true gap> LoadPackage( "LinearAlgebraForCAP" ); diff --git a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_a_zero_object.tst b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_a_zero_object.tst index e90dea2f7b..974114c650 100644 --- a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_a_zero_object.tst +++ b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_a_zero_object.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_direct_sums.tst b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_direct_sums.tst index b368c0b409..77ca449619 100644 --- a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_direct_sums.tst +++ b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_direct_sums.tst @@ -6,7 +6,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_preadditive_structure.tst b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_preadditive_structure.tst index b3f0e13c4f..810e7849cf 100644 --- a/CompilerForCAP/tst/300_proof_AdditiveClosure_has_preadditive_structure.tst +++ b/CompilerForCAP/tst/300_proof_AdditiveClosure_has_preadditive_structure.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_AdditiveClosure_hom_structure.tst b/CompilerForCAP/tst/300_proof_AdditiveClosure_hom_structure.tst index 13d9317ddf..7d87615862 100644 --- a/CompilerForCAP/tst/300_proof_AdditiveClosure_hom_structure.tst +++ b/CompilerForCAP/tst/300_proof_AdditiveClosure_hom_structure.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_CategoryOfRows_has_kernels.tst b/CompilerForCAP/tst/300_proof_CategoryOfRows_has_kernels.tst index a4b1791c89..09db215243 100644 --- a/CompilerForCAP/tst/300_proof_CategoryOfRows_has_kernels.tst +++ b/CompilerForCAP/tst/300_proof_CategoryOfRows_has_kernels.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_RingAsCategory_has_associative_composition.tst b/CompilerForCAP/tst/300_proof_RingAsCategory_has_associative_composition.tst index c12438bdcf..126bec0d7e 100644 --- a/CompilerForCAP/tst/300_proof_RingAsCategory_has_associative_composition.tst +++ b/CompilerForCAP/tst/300_proof_RingAsCategory_has_associative_composition.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/300_proof_RingAsCategory_has_preadditive_structure.tst b/CompilerForCAP/tst/300_proof_RingAsCategory_has_preadditive_structure.tst index 0255d19e2b..ce1f1ad203 100644 --- a/CompilerForCAP/tst/300_proof_RingAsCategory_has_preadditive_structure.tst +++ b/CompilerForCAP/tst/300_proof_RingAsCategory_has_preadditive_structure.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", ">= 2024.06-03", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", ">= 2025.06-01", false ); true # diff --git a/CompilerForCAP/tst/300_proof_RingAsCategory_of_k_algebra_has_linear_structure.tst b/CompilerForCAP/tst/300_proof_RingAsCategory_of_k_algebra_has_linear_structure.tst index 4ace85c6de..a0bd6c456b 100644 --- a/CompilerForCAP/tst/300_proof_RingAsCategory_of_k_algebra_has_linear_structure.tst +++ b/CompilerForCAP/tst/300_proof_RingAsCategory_of_k_algebra_has_linear_structure.tst @@ -5,6 +5,8 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # +gap> LoadPackage( "AdditiveClosuresForCAP", ">= 2025.06-01", false ); +true gap> LoadPackage( "FreydCategoriesForCAP", ">= 2024.06-03", false ); true diff --git a/CompilerForCAP/tst/300_proof_hom_structure_for_linear_categories.tst b/CompilerForCAP/tst/300_proof_hom_structure_for_linear_categories.tst index a513e078b0..15be0d87da 100644 --- a/CompilerForCAP/tst/300_proof_hom_structure_for_linear_categories.tst +++ b/CompilerForCAP/tst/300_proof_hom_structure_for_linear_categories.tst @@ -5,7 +5,7 @@ gap> old_screen_width := SizeScreen( )[1];; gap> SizeScreen( [ 4096 ] );; # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/CAP_JIT_INTERNAL_TELESCOPED_ITERATION.tst b/CompilerForCAP/tst/CAP_JIT_INTERNAL_TELESCOPED_ITERATION.tst index 4b20170ab6..78bcca9cf1 100644 --- a/CompilerForCAP/tst/CAP_JIT_INTERNAL_TELESCOPED_ITERATION.tst +++ b/CompilerForCAP/tst/CAP_JIT_INTERNAL_TELESCOPED_ITERATION.tst @@ -3,7 +3,7 @@ gap> START_TEST( "CAP_JIT_INTERNAL_TELESCOPED_ITERATION" ); # gap> LoadPackage( "CompilerForCAP", false ); true -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true gap> LoadPackage( "LinearAlgebraForCAP", false ); true diff --git a/CompilerForCAP/tst/CapJitCompiledFunction.tst b/CompilerForCAP/tst/CapJitCompiledFunction.tst index c43438b5e8..2dac7058f4 100644 --- a/CompilerForCAP/tst/CapJitCompiledFunction.tst +++ b/CompilerForCAP/tst/CapJitCompiledFunction.tst @@ -3,7 +3,7 @@ gap> START_TEST( "CapJitCompiledFunction" ); # gap> LoadPackage( "CompilerForCAP", false ); true -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/StopCompilationAtCategory.tst b/CompilerForCAP/tst/StopCompilationAtCategory.tst index 4e6b502551..ab85e607f4 100644 --- a/CompilerForCAP/tst/StopCompilationAtCategory.tst +++ b/CompilerForCAP/tst/StopCompilationAtCategory.tst @@ -1,7 +1,7 @@ gap> START_TEST( "StopCompilationAtCategory" ); # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/CompilerForCAP/tst/proof_assistant.tst b/CompilerForCAP/tst/proof_assistant.tst index de8fbd010d..d673858923 100644 --- a/CompilerForCAP/tst/proof_assistant.tst +++ b/CompilerForCAP/tst/proof_assistant.tst @@ -1,7 +1,7 @@ gap> START_TEST( "proof_assistant" ); # -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true # diff --git a/FreydCategoriesForCAP/PackageInfo.g b/FreydCategoriesForCAP/PackageInfo.g index 74a9f6ec3b..3e9110af39 100644 --- a/FreydCategoriesForCAP/PackageInfo.g +++ b/FreydCategoriesForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "FreydCategoriesForCAP", Subtitle := "Freyd categories - Formal (co)kernels for additive categories", -Version := "2025.06-08", +Version := "2025.06-09", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", @@ -104,12 +104,13 @@ Dependencies := rec( NeededOtherPackages := [ [ "CAP", ">= 2025.06-05" ], [ "MatricesForHomalg", ">= 2023.01-01" ], [ "GradedRingForHomalg", ">=2019.08.07" ], + [ "AdditiveClosuresForCAP", ">= 2025.06-01" ], [ "MonoidalCategories", ">= 2024.09-02" ], - [ "GeneralizedMorphismsForCAP", ">= 2018.06.15" ] + [ "GeneralizedMorphismsForCAP", ">= 2018.06.15" ], ], SuggestedOtherPackages := [ [ "FinSetsForCAP", ">= 2023.07-03" ], - [ "GroupsAsCategoriesForCAP", ">= 2025.06-01" ], + [ "GroupsAsCategoriesForCAP", ">= 2025.06-02" ], ], ExternalConditions := [ ], ), diff --git a/FreydCategoriesForCAP/README.md b/FreydCategoriesForCAP/README.md index f9a8344b43..538fb0e252 100644 --- a/FreydCategoriesForCAP/README.md +++ b/FreydCategoriesForCAP/README.md @@ -15,7 +15,6 @@ This package includes implementations (amongst others) of: - [Freyd categories](#freyd-categories) - [Cokernel image closures](#cokernel-image-closures) - [Adelman categories](#adelman-categories) -- [Additive closures](#additive-closures) ## Freyd categories @@ -39,10 +38,6 @@ Sebastian Posur, [*Closing the category of finitely presented functors under ima Adelman categories provide a universal way of turning an additive category into an abelian category. -## Additive closures - -Additive closures provide a universal way of equipping a given Ab-category with finite direct sums. - #### Paper (describing the underlying algorithms) Sebastian Posur, [*Methods of constructive category theory*](https://arxiv.org/abs/1908.04132). diff --git a/FreydCategoriesForCAP/examples/Basics.gi b/FreydCategoriesForCAP/examples/Basics.gi index 26973e21dc..bd04bdcc70 100644 --- a/FreydCategoriesForCAP/examples/Basics.gi +++ b/FreydCategoriesForCAP/examples/Basics.gi @@ -11,86 +11,12 @@ R := HomalgRingOfIntegers();; cat := CategoryOfRows( R );; obj1 := CategoryOfRowsObject( 1, cat );; obj2 := CategoryOfRowsObject( 2, cat );; -IsIsomorphicForObjects( obj1, obj2 ); -#! false -IsIsomorphicForObjects( obj2, obj2 ); -#! true -IsIsomorphism( SomeIsomorphismBetweenObjects( obj2, obj2 ) ); -#! true -id := IdentityMorphism( obj2 );; -alpha := CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );; -beta := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );; -comp := PreCompose( alpha, beta );; -IsZeroForMorphisms( comp );; -zero := ZeroMorphism( obj1, obj2 );; -IsZeroForMorphisms( zero );; -ZeroObject( cat );; -UniversalMorphismIntoZeroObject( obj2 );; -UniversalMorphismFromZeroObject( obj1 );; -IsCongruentForMorphisms( - SumOfMorphisms( obj1, [ alpha, alpha, alpha ], obj2 ), - AdditionForMorphisms( alpha, AdditionForMorphisms( alpha, alpha ) ) -); -#! true -IsCongruentForMorphisms( - SumOfMorphisms( obj1, [ ], obj2 ), - ZeroMorphism( obj1, obj2 ) -); -#! true -DirectSum( obj1, obj2 );; -DirectSumFunctorial( [ alpha, beta, id ] );; -proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );; -IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 3 ) ); -#! true -UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );; -inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );; -IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 3 ) ); -#! true gamma := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );; -IsColiftable( beta, gamma ); -#! true -IsColiftable( gamma, beta ); -#! false -ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );; -ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );; -lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );; -lift_arg_2 := gamma + gamma;; -IsLiftable( lift_arg_1, lift_arg_2 );; -Lift( lift_arg_1, lift_arg_2 );; -pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );; -pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );; -IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );; -inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );; -inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );; -IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );; -WeakKernelLift( WeakCokernelProjection( gamma ), gamma );; -pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );; -pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );; -UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );; ## Freyd categories freyd := FreydCategory( cat );; -IsAbelianCategory( freyd );; +IsAbelianCategory( freyd ); +#! true obj_gamma := FreydCategoryObject( gamma );; u := RandomMorphismWithFixedSource( obj_gamma, [ [5], [5] ] );; IsWellDefined( u ) and IsEqualForObjects( Source(u), obj_gamma ); @@ -150,20 +76,6 @@ Rows_S := CategoryOfRows( S );; S3 := CategoryOfRowsObject( 3, Rows_S );; S1 := CategoryOfRowsObject( 1, Rows_S );; mor := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,y,z]", 3, 1, S ), S1 );; -biased_w := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );; -biased_h := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );; -BiasedWeakFiberProduct( biased_h, biased_w );; -ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );; -IsCongruentForMorphisms( - PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ), - biased_h -); -#! true -IsCongruentForMorphisms( - PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )), - biased_h -); -#! true k := FreydCategoryObject( mor );; @@ -173,11 +85,6 @@ ColiftAlongEpimorphism( CokernelProjection( k ), CokernelProjection( k ) );; ## Homomorphism structures -a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );; -IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; -a := ZeroObjectFunctorial( cat );; -IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; - Z4 := FreydCategoryObject( AsCategoryOfRowsMorphism( HomalgMatrix( "[4]", 1, 1, R ), cat ) );; Z3 := FreydCategoryObject( AsCategoryOfRowsMorphism( HomalgMatrix( "[3]", 1, 1, R ), cat ) );; HomomorphismStructureOnObjects( Z4, Z2 );; @@ -232,58 +139,12 @@ R := HomalgRingOfIntegers();; cat := CategoryOfColumns( R );; obj1 := CategoryOfColumnsObject( 1, cat );; obj2 := CategoryOfColumnsObject( 2, cat );; -id := IdentityMorphism( obj2 );; -alpha := CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 1, 2, R ), obj2 );; -beta := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );; -comp := PreCompose( alpha, beta );; -IsZeroForMorphisms( comp );; -zero := ZeroMorphism( obj1, obj2 );; -IsZeroForMorphisms( zero );; -ZeroObject( cat );; -UniversalMorphismIntoZeroObject( obj2 );; -UniversalMorphismFromZeroObject( obj1 );; -DirectSum( obj1, obj2 );; -DirectSumFunctorial( [ alpha, beta, id ] );; -proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );; -IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) ); -#! true -UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );; -inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );; -IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) ); -#! true -IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) ); -#! true -IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) ); -#! true gamma := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );; -IsColiftable( beta, gamma ); -#! false -IsColiftable( gamma, beta ); -#! false -ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );; -ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );; -lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );; -lift_arg_2 := gamma + gamma;; -IsLiftable( lift_arg_1, lift_arg_2 );; -Lift( lift_arg_1, lift_arg_2 );; -pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );; -pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );; -IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );; -inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );; -inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );; -IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );; -WeakKernelLift( WeakCokernelProjection( gamma ), gamma );; -pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );; -pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );; -UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );; ## Freyd categories freyd := FreydCategory( cat );; -IsAbelianCategory( freyd );; +IsAbelianCategory( freyd ); +#! true obj_gamma := FreydCategoryObject( gamma );; f := FreydCategoryMorphism( obj_gamma, gamma, obj_gamma );; witness := MorphismWitness( f );; @@ -313,20 +174,6 @@ Cols_S := CategoryOfColumns( S );; S3 := CategoryOfColumnsObject( 3, Cols_S );; S1 := CategoryOfColumnsObject( 1, Cols_S );; mor := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,y,z]", 1, 3, S ), S1 );; -biased_w := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );; -biased_h := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );; -BiasedWeakFiberProduct( biased_h, biased_w );; -ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );; -IsCongruentForMorphisms( - PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ), - biased_h -); -#! true -IsCongruentForMorphisms( - PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )), - biased_h -); -#! true k := FreydCategoryObject( mor );; @@ -336,11 +183,6 @@ ColiftAlongEpimorphism( CokernelProjection( k ), CokernelProjection( k ) );; ## Homomorphism structures -a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );; -IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; -a := ZeroObjectFunctorial( cat );; -IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );; - Z4 := FreydCategoryObject( AsCategoryOfColumnsMorphism( HomalgMatrix( "[4]", 1, 1, R ), cat ) );; Z3 := FreydCategoryObject( AsCategoryOfColumnsMorphism( HomalgMatrix( "[3]", 1, 1, R ), cat ) );; HomomorphismStructureOnObjects( Z4, Z2 );; @@ -365,8 +207,6 @@ Lift( alpha, gamma );; Colift( lift, alpha );; IsCongruentForMorphisms( PreCompose( lift, Colift( lift, alpha ) ), alpha );; - - lift := FreydCategoryMorphism( S2_freyd, CategoryOfColumnsMorphism( S2, HomalgMatrix( "[x,y,z,x^2,1,z+1]", 3, 2, S ), S3 ), S3_freyd );; gamma := FreydCategoryMorphism( S3_freyd, CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,y,z,z+1, x^2,y^2,z^2,z^2+1, x^3,y^3,z^3,z^3+1]", 4,3, S ), S4 ), S4_freyd );; alpha := PreCompose( lift, gamma );; diff --git a/FreydCategoriesForCAP/examples/Simplify.g b/FreydCategoriesForCAP/examples/Simplify.g index 7a209c3154..e7fafb38ed 100644 --- a/FreydCategoriesForCAP/examples/Simplify.g +++ b/FreydCategoriesForCAP/examples/Simplify.g @@ -1,86 +1,12 @@ #! @Chapter Example on category of rows -LoadPackage( "FreydCategoriesForCAP" );; LoadPackage( "RingsForHomalg" ); +LoadPackage( "FreydCategoriesForCAP" );; ##################################### #! @Section Simplifications ##################################### -#! @Example -R := HomalgRingOfIntegers();; -rows := CategoryOfRows( R );; -M := HomalgMatrix( [ [ 2, 2, 2 ], [ 3, 3, 3 ] ], 2, 3, R );; -alpha := AsCategoryOfRowsMorphism( M, rows );; -pi := PreCompose( [ - SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), - SimplifySourceAndRange( alpha, infinity ), - SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ] );; -IsCongruentForMorphisms( pi, alpha ); -#! true -IsOne( - PreCompose( SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), SimplifySourceAndRange_IsoToInputSource( alpha, infinity ) ) -); -#! true -IsOne( - PreCompose( SimplifySourceAndRange_IsoFromInputRange( alpha, infinity ), SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ) -); -#! true -pi2 := PreCompose( - SimplifySource_IsoFromInputObject( alpha, infinity ), - SimplifySource( alpha, infinity ) -);; -IsCongruentForMorphisms( pi2, alpha ); -#! true -IsOne( PreCompose( SimplifySource_IsoFromInputObject( alpha, infinity ), SimplifySource_IsoToInputObject( alpha, infinity ) ) ); -#! true -pi3 := PreCompose( - SimplifyRange( alpha, infinity ), - SimplifyRange_IsoToInputObject( alpha, infinity ) -);; -IsCongruentForMorphisms( pi3, alpha ); -#! true -IsOne( PreCompose( SimplifyRange_IsoFromInputObject( alpha, infinity ), SimplifyRange_IsoToInputObject( alpha, infinity ) ) ); -#! true -#! @EndExample - -#! @Example -R := HomalgRingOfIntegers();; -cols := CategoryOfColumns( R );; -M := HomalgMatrix( [ [ 2, 2, 2 ], [ 3, 3, 3 ] ], 2, 3, R );; -alpha := AsCategoryOfColumnsMorphism( M, cols );; -pi := PreCompose( [ - SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), - SimplifySourceAndRange( alpha, infinity ), - SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ] );; -IsCongruentForMorphisms( pi, alpha ); -#! true -IsOne( - PreCompose( SimplifySourceAndRange_IsoFromInputSource( alpha, infinity ), SimplifySourceAndRange_IsoToInputSource( alpha, infinity ) ) -); -#! true -IsOne( - PreCompose( SimplifySourceAndRange_IsoFromInputRange( alpha, infinity ), SimplifySourceAndRange_IsoToInputRange( alpha, infinity ) ) -); -#! true -pi2 := PreCompose( - SimplifySource_IsoFromInputObject( alpha, infinity ), - SimplifySource( alpha, infinity ) -);; -IsCongruentForMorphisms( pi2, alpha ); -#! true -IsOne( PreCompose( SimplifySource_IsoFromInputObject( alpha, infinity ), SimplifySource_IsoToInputObject( alpha, infinity ) ) ); -#! true -pi3 := PreCompose( - SimplifyRange( alpha, infinity ), - SimplifyRange_IsoToInputObject( alpha, infinity ) -);; -IsCongruentForMorphisms( pi3, alpha ); -#! true -IsOne( PreCompose( SimplifyRange_IsoFromInputObject( alpha, infinity ), SimplifyRange_IsoToInputObject( alpha, infinity ) ) ); -#! true -#! @EndExample - #! @Example Qxyz := HomalgFieldOfRationalsInDefaultCAS( ) * "x,y,z";; A3 := RingOfDerivations( Qxyz, "Dx,Dy,Dz" );; diff --git a/FreydCategoriesForCAP/gap/AdditiveClosureDerivedMethods.gi b/FreydCategoriesForCAP/gap/AdditiveClosureDerivedMethods.gi deleted file mode 100644 index 583994a14d..0000000000 --- a/FreydCategoriesForCAP/gap/AdditiveClosureDerivedMethods.gi +++ /dev/null @@ -1,67 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-or-later -# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories -# -# Implementations -# - -## -AddDerivationToCAP( WeakKernelEmbedding, - "WeakKernelEmbedding in additive closures of categories with finite number of objects and homomorphism structure", - [ [ ObjectConstructor, 2 ], - [ BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory, 2 ], - [ IdentityMorphism, 2 ], - [ SetOfObjectsOfCategory, 1, UnderlyingCategory ], - [ DirectSum, 1 ], - [ UniversalMorphismFromDirectSumWithGivenDirectSum, 1 ] - ], - - function ( cat, phi ) - local underlying_cat, objs, tau, diagram, S; - - underlying_cat := UnderlyingCategory( cat ); - - objs := List( SetOfObjectsOfCategory( underlying_cat ), o -> ObjectConstructor( cat, [ o ] ) ); - - tau := Concatenation( List( objs, - o -> Concatenation( BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( cat, [ [ IdentityMorphism( cat, o ) ] ], [ [ phi ] ] ) ) ) ); - - diagram := List( tau, m -> Source( m ) ); - - S := DirectSum( cat, diagram ); - - return UniversalMorphismFromDirectSumWithGivenDirectSum( cat, diagram, Source( phi ), tau, S ); - - end : CategoryGetters := rec( underlying_cat := UnderlyingCategory ), - CategoryFilter := cat -> HasUnderlyingCategory( cat ) and HasIsObjectFiniteCategory( UnderlyingCategory( cat ) ) and IsObjectFiniteCategory( UnderlyingCategory( cat ) ) -); - -## -AddDerivationToCAP( WeakCokernelProjection, - "WeakCokernelProjection in additive closures of categories with finite number of objects and homomorphism structure", - [ [ ObjectConstructor, 2 ], - [ BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory, 2 ], - [ IdentityMorphism, 2 ], - [ SetOfObjectsOfCategory, 1, UnderlyingCategory ], - [ DirectSum, 1 ], - [ UniversalMorphismIntoDirectSumWithGivenDirectSum, 1 ] - ], - - function ( cat, phi ) - local underlying_cat, objs, tau, diagram, S; - - underlying_cat := UnderlyingCategory( cat ); - - objs := List( SetOfObjectsOfCategory( underlying_cat ), o -> ObjectConstructor( cat, [ o ] ) ); - - tau := Concatenation( List( objs, - o -> Concatenation( BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( cat, [ [ phi ] ], [ [ IdentityMorphism( cat, o ) ] ] ) ) ) ); - - diagram := List( tau, m -> Target( m ) ); - - S := DirectSum( cat, diagram ); - - return UniversalMorphismIntoDirectSumWithGivenDirectSum( cat, diagram, Target( phi ), tau, S ); - - end : CategoryGetters := rec( underlying_cat := UnderlyingCategory ), - CategoryFilter := cat -> HasUnderlyingCategory( cat ) and HasIsObjectFiniteCategory( UnderlyingCategory( cat ) ) and IsObjectFiniteCategory( UnderlyingCategory( cat ) ) -); diff --git a/FreydCategoriesForCAP/gap/FreydCategoriesDerivedMethods.gi b/FreydCategoriesForCAP/gap/FreydCategoriesDerivedMethods.gi index 4ee0305dad..c73bdd32a4 100644 --- a/FreydCategoriesForCAP/gap/FreydCategoriesDerivedMethods.gi +++ b/FreydCategoriesForCAP/gap/FreydCategoriesDerivedMethods.gi @@ -4,283 +4,6 @@ # Implementations # -## Derivations for basic operations with existing WithGiven - -## -AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProduct, - "ProjectionInSecondFactorOfWeakBiFiberProduct using ProjectionInFirstFactorOfWeakBiFiberProduct and Lift", - [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], - [ Lift, 1 ], - [ PreCompose, 1 ] ], - - function( cat, alpha, beta ) - local first_projection; - - first_projection := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - return Lift( cat, PreCompose( cat, first_projection, alpha ), beta ); - -end ); - -## -AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProduct, - "ProjectionInFirstFactorOfWeakBiFiberProduct using ProjectionInSecondFactorOfWeakBiFiberProduct and Lift", - [ [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], - [ Lift, 1 ], - [ PreCompose, 1 ] ], - - function( cat, alpha, beta ) - local second_projection; - - second_projection := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - return Lift( cat, PreCompose( cat, second_projection, beta ), alpha ); - -end ); - -## -AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushout, - "InjectionOfSecondCofactorOfWeakBiPushout using InjectionOfFirstCofactorOfWeakBiPushout and Colift", - [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], - [ Colift, 1 ], - [ PreCompose, 1 ] ], - - function( cat, alpha, beta ) - local first_injection; - - first_injection := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); - - return Colift( cat, beta, PreCompose( cat, alpha, first_injection ) ); - -end ); - -## -AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushout, - "InjectionOfFirstCofactorOfWeakBiPushout using InjectionOfSecondCofactorOfWeakBiPushout and Colift", - [ [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], - [ Colift, 1 ], - [ PreCompose, 1 ] ], - - function( cat, alpha, beta ) - local second_injection; - - second_injection := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); - - return Colift( cat, alpha, PreCompose( cat, beta, second_injection ) ); - -end ); - -## -AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProduct, - "UniversalMorphismIntoWeakBiFiberProduct using Lift", - [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], - [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], - [ Lift, 1 ], - [ UniversalMorphismIntoDirectSum, 2 ] ], - - function( cat, alpha, beta, test_mor_1, test_mor_2 ) - local projection_1, projection_2; - - projection_1 := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - projection_2 := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - return Lift( cat, UniversalMorphismIntoDirectSum( cat, [ test_mor_1, test_mor_2 ] ), - UniversalMorphismIntoDirectSum( cat, [ projection_1, projection_2 ] ) ); - -end ); - -## -AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProduct, - "UniversalMorphismIntoBiasedWeakFiberProduct using Lift", - [ [ Lift, 1 ], - [ ProjectionOfBiasedWeakFiberProduct, 1 ] ], - - function( cat, alpha, beta, test_mor ) - - return Lift( cat, - test_mor, - ProjectionOfBiasedWeakFiberProduct( cat, alpha, beta ) ); - -end ); - - -## -AddDerivationToCAP( UniversalMorphismFromWeakBiPushout, - "UniversalMorphismFromWeakBiPushout using Colift", - [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], - [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], - [ Colift, 1 ], - [ UniversalMorphismFromDirectSum, 2 ] ], - - function( cat, alpha, beta, test_mor_1, test_mor_2 ) - local injection_1, injection_2; - - injection_1 := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); - - injection_2 := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); - - return Colift( cat, UniversalMorphismFromDirectSum( cat, [ injection_1, injection_2 ] ), - UniversalMorphismFromDirectSum( cat, [ test_mor_1, test_mor_2 ] ) ); - -end ); - -## -AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushout, - "UniversalMorphismFromBiasedWeakPushout using Colift", - [ [ Colift, 1 ], - [ InjectionOfBiasedWeakPushout, 1 ] ], - - function( cat, alpha, beta, test_mor ) - - return Colift( cat, - InjectionOfBiasedWeakPushout( cat, alpha, beta ), - test_mor ); - -end ); - -## -AddDerivationToCAP( WeakKernelLift, - "WeakKernelLift as Lift of WeakKernelEmbedding", - [ [ Lift, 1 ], - [ WeakKernelEmbedding, 1 ] ], - - function( cat, mor, test_mor ) - - return Lift( cat, test_mor, WeakKernelEmbedding( cat, mor ) ); - -end ); - -## -AddDerivationToCAP( WeakCokernelColift, - "WeakCokernelColift as Colift of WeakCokernelProjection", - [ [ Colift, 1 ], - [ WeakCokernelProjection, 1 ] ], - - function( cat, mor, test_mor ) - - return Colift( cat, WeakCokernelProjection( cat, mor ), test_mor ); - -end ); - - -## Derivations for basic operations without existing WithGiven -## -AddDerivationToCAP( WeakKernelObject, - "WeakKernelObject as the source of WeakKernelEmbedding", - [ [ WeakKernelEmbedding, 1 ] ], - - function( cat, mor ) - - return Source( WeakKernelEmbedding( cat, mor ) ); - -end ); - -## -AddDerivationToCAP( WeakCokernelObject, - "WeakCokernelObject as the range of WeakCokernelProjection", - [ [ WeakCokernelProjection, 1 ] ], - - function( cat, mor ) - - return Range( WeakCokernelProjection( cat, mor ) ); - -end ); - -## -AddDerivationToCAP( WeakBiFiberProduct, - "WeakBiFiberProduct as the source of ProjectionInFirstFactorOfWeakBiFiberProduct", - [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ] ], - - function( cat, alpha, beta ) - - return Source( ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ) ); - -end ); - -## -AddDerivationToCAP( WeakBiFiberProduct, - "WeakBiFiberProduct as the source of ProjectionInSecondFactorOfWeakBiFiberProduct", - [ [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ] ], - - function( cat, alpha, beta ) - - return Source( ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ) ); - -end ); - -## -AddDerivationToCAP( BiasedWeakFiberProduct, - "BiasedWeakFiberProduct as the source of ProjectionOfBiasedWeakFiberProduct", - [ [ ProjectionOfBiasedWeakFiberProduct, 1 ] ], - - function( cat, alpha, beta ) - - return Source( ProjectionOfBiasedWeakFiberProduct( cat, alpha, beta ) ); - -end ); - - -## -AddDerivationToCAP( WeakBiPushout, - "WeakBiPushout as the range of InjectionOfFirstCofactorOfWeakBiPushout", - [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ] ], - - function( cat, alpha, beta ) - - return Range( InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ) ); - -end ); - -## -AddDerivationToCAP( WeakBiPushout, - "WeakBiPushout as the range of InjectionOfSecondCofactorOfWeakBiPushout", - [ [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ] ], - - function( cat, alpha, beta ) - - return Range( InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ) ); - -end ); - -## -AddDerivationToCAP( BiasedWeakPushout, - "BiasedWeakPushout as the range of InjectionOfBiasedWeakPushout", - [ [ InjectionOfBiasedWeakPushout, 1 ] ], - - function( cat, alpha, beta ) - - return Range( InjectionOfBiasedWeakPushout( cat, alpha, beta ) ); - -end ); - - -## abelian derivations - -## -AddDerivationToCAP( IsMonomorphism, - "IsMonomorphism by deciding whether WeakKernelEmbedding is zero", - [ [ IsZeroForMorphisms, 1 ], - [ WeakKernelEmbedding, 1 ] ], - - function( cat, alpha ) - - return IsZeroForMorphisms( cat, WeakKernelEmbedding( cat, alpha ) ); - -end ); - -## -AddDerivationToCAP( IsEpimorphism, - "IsEpimorphism by deciding whether WeakCokernelProjection is zero", - [ [ IsZeroForMorphisms, 1 ], - [ WeakCokernelProjection, 1 ] ], - - function( cat, alpha ) - - return IsZeroForMorphisms( cat, WeakCokernelProjection( cat, alpha ) ); - -end ); - ## AddDerivationToCAP( SomeProjectiveObjectForKernelObject, "SomeProjectiveObjectForKernelObject as the source of EpimorphismFromSomeProjectiveObjectForKernelObject", @@ -292,369 +15,3 @@ AddDerivationToCAP( SomeProjectiveObjectForKernelObject, end ); -## -AddDerivationToCAP( WeakBiFiberProductMorphismToDirectSum, - "WeakBiFiberProductMorphismToDirectSum using UniversalMorphismIntoDirectSum of the two weak bi-fiber product projections", - [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], - [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], - [ UniversalMorphismIntoDirectSum, 1 ] ], - - function( cat, alpha, beta ) - local projection_1, projection_2; - - projection_1 := ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - projection_2 := ProjectionInSecondFactorOfWeakBiFiberProduct( cat, alpha, beta ); - - return UniversalMorphismIntoDirectSum( cat, [ projection_1, projection_2 ] ); - -end ); - -## -AddDerivationToCAP( DirectSumMorphismToWeakBiPushout, - "DirectSumMorphismToWeakBiPushout using UniversalMorphismFromDirectSum of the two weak bi-pushout injections", - [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], - [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], - [ UniversalMorphismFromDirectSum, 1 ] ], - - function( cat, alpha, beta ) - local injection_1, injection_2; - - injection_1 := InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); - - injection_2 := InjectionOfSecondCofactorOfWeakBiPushout( cat, alpha, beta ); - - return UniversalMorphismFromDirectSum( cat, [ injection_1, injection_2 ] ); - -end ); - -## -AddDerivationToCAP( WeakBiFiberProduct, - "WeakBiFiberProduct as the source of WeakBiFiberProductMorphismToDirectSum", - [ [ WeakBiFiberProductMorphismToDirectSum, 1 ] ], - - function( cat, alpha, beta ) - - return Source( WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ) ); - -end ); - -## -AddDerivationToCAP( WeakBiPushout, - "WeakBiPushout as the range of DirectSumMorphismToWeakBiPushout", - [ [ DirectSumMorphismToWeakBiPushout, 1 ] ], - - function( cat, alpha, beta ) - - return Range( DirectSumMorphismToWeakBiPushout( cat, alpha, beta ) ); - -end ); - -## Final derivations - -## -AddFinalDerivationBundle( "weak kernel using kernel", - [ [ KernelObject, 1 ], - [ KernelEmbedding, 1 ], - [ KernelLift, 1 ] ], - - [ WeakKernelObject, - WeakKernelEmbedding, - WeakKernelLift ], -[ - WeakKernelObject, - [ [ KernelObject, 1 ] ], - function( cat, morphism ) - - return KernelObject( cat, morphism ); - - end -], -[ - WeakKernelEmbedding, - [ [ KernelEmbedding, 1 ] ], - function( cat, morphism ) - - return KernelEmbedding( cat, morphism ); - - end -], -[ - WeakKernelLift, - [ [ KernelLift, 1 ] ], - function( cat, morphism, test_mor ) - - return KernelLift( cat, morphism, test_mor ); - - end -] ); - -## -AddFinalDerivationBundle( "weak cokernel using cokernel", - [ [ CokernelObject, 1 ], - [ CokernelProjection, 1 ], - [ CokernelColift, 1 ] ], - - [ WeakCokernelObject, - WeakCokernelProjection, - WeakCokernelColift ], -[ - WeakCokernelObject, - [ [ CokernelObject, 1 ] ], - function( cat, morphism ) - - return CokernelObject( cat, morphism ); - - end -], -[ - WeakCokernelProjection, - [ [ CokernelProjection, 1 ] ], - function( cat, morphism ) - - return CokernelProjection( cat, morphism ); - - end -], -[ - WeakCokernelColift, - [ [ CokernelColift, 1 ] ], - function( cat, morphism, test_mor ) - - return CokernelColift( cat, morphism, test_mor ); - - end -] ); - -## Final derivation for weak fiber products and weak pushouts. -## Decision: we use a derivation from weak kernels and direct sums - -## -AddFinalDerivationBundle( "WeakBiFiberProductMorphismToDirectSum via WeakKernelEmbedding and direct sum", - [ [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakKernelEmbedding, 1 ], - [ ProjectionInFactorOfDirectSum, 1 ], - [ UniversalMorphismIntoDirectSum, 1 ], - [ WeakKernelLift, 1 ], - ], - [ - WeakBiFiberProduct, - ProjectionInFirstFactorOfWeakBiFiberProduct, - ProjectionInSecondFactorOfWeakBiFiberProduct, - UniversalMorphismIntoWeakBiFiberProduct, - WeakBiFiberProductMorphismToDirectSum, - ], -[ - WeakBiFiberProductMorphismToDirectSum, - [ [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakKernelEmbedding, 1 ] ], - function( cat, alpha, beta ) - local direct_sum_diagram, direct_sum, proj1_alpha, proj2_beta, difference; - - direct_sum_diagram := [ Source( alpha ), Source( beta ) ]; - - direct_sum := DirectSum( cat, direct_sum_diagram ); - - proj1_alpha := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ), alpha ); - - proj2_beta := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ), beta ); - - difference := SubtractionForMorphisms( cat, proj1_alpha, proj2_beta ); - - return WeakKernelEmbedding( cat, difference ); - - end -], -[ - ProjectionInFirstFactorOfWeakBiFiberProduct, - [ [ WeakBiFiberProductMorphismToDirectSum, 1 ], - [ PreCompose, 1 ], - [ ProjectionInFactorOfDirectSum, 1 ] ], - function( cat, alpha, beta ) - local morphism_to_direct_sum; - - morphism_to_direct_sum := WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ); - - return PreCompose( cat, morphism_to_direct_sum, ProjectionInFactorOfDirectSum( cat, [ Source( alpha ), Source( beta ) ], 1 ) ); - - end -], -[ - ProjectionInSecondFactorOfWeakBiFiberProduct, - [ [ WeakBiFiberProductMorphismToDirectSum, 1 ], - [ PreCompose, 1 ], - [ ProjectionInFactorOfDirectSum, 1 ] ], - function( cat, alpha, beta ) - local morphism_to_direct_sum; - - morphism_to_direct_sum := WeakBiFiberProductMorphismToDirectSum( cat, alpha, beta ); - - return PreCompose( cat, morphism_to_direct_sum, ProjectionInFactorOfDirectSum( cat, [ Source( alpha ), Source( beta ) ], 2 ) ); - - end -], -[ - UniversalMorphismIntoWeakBiFiberProduct, - [ [ UniversalMorphismIntoDirectSum, 1 ], - [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ ProjectionInFactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakKernelLift, 1 ] ], - function( cat, alpha, beta, test_mor_1, test_mor_2 ) - local test_mor, direct_sum_diagram, direct_sum, proj1_alpha, proj2_beta, difference; - - test_mor := UniversalMorphismIntoDirectSum( cat, [ test_mor_1, test_mor_2 ] ); - - direct_sum_diagram := [ Source( alpha ), Source( beta ) ]; - - direct_sum := DirectSum( cat, direct_sum_diagram ); - - proj1_alpha := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ), alpha ); - - proj2_beta := PreCompose( cat, ProjectionInFactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ), beta ); - - difference := SubtractionForMorphisms( cat, proj1_alpha, proj2_beta ); - - return WeakKernelLift( cat, difference, test_mor ); - - end -] ); - -## weak bi-pushout -## -AddFinalDerivationBundle( "DirectSumMorphismToWeakBiPushout via WeakCokernelProjection and direct sum", - [ [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakCokernelProjection, 1 ], - [ InjectionOfCofactorOfDirectSum, 1 ], - [ UniversalMorphismFromDirectSum, 1 ], - [ WeakCokernelColift, 1 ], - ], - [ - WeakBiPushout, - InjectionOfFirstCofactorOfWeakBiPushout, - InjectionOfSecondCofactorOfWeakBiPushout, - UniversalMorphismFromWeakBiPushout, - DirectSumMorphismToWeakBiPushout, - ], -[ - DirectSumMorphismToWeakBiPushout, - [ [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakCokernelProjection, 1 ] ], - function( cat, alpha, beta ) - local direct_sum_diagram, direct_sum, alpha_inj1, beta_inj2, difference; - - direct_sum_diagram := [ Range( alpha ), Range( beta ) ]; - - direct_sum := DirectSum( cat, direct_sum_diagram ); - - alpha_inj1 := PreCompose( cat, alpha, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ) ); - - beta_inj2 := PreCompose( cat, beta, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ) ); - - difference := SubtractionForMorphisms( cat, alpha_inj1, beta_inj2 ); - - return WeakCokernelProjection( cat, difference ); - -end -], -[ - InjectionOfFirstCofactorOfWeakBiPushout, - [ [ DirectSumMorphismToWeakBiPushout, 1 ], - [ PreCompose, 1 ], - [ InjectionOfCofactorOfDirectSum, 1 ] ], - function( cat, alpha, beta ) - local direct_sum_morphism; - - direct_sum_morphism := DirectSumMorphismToWeakBiPushout( cat, alpha, beta ); - - return PreCompose( cat, InjectionOfCofactorOfDirectSum( cat, [ Range( alpha ), Range( beta ) ], 1 ), direct_sum_morphism ); - - end -], -[ - InjectionOfSecondCofactorOfWeakBiPushout, - [ [ DirectSumMorphismToWeakBiPushout, 1 ], - [ PreCompose, 1 ], - [ InjectionOfCofactorOfDirectSum, 1 ] ], - function( cat, alpha, beta ) - local direct_sum_morphism; - - direct_sum_morphism := DirectSumMorphismToWeakBiPushout( cat, alpha, beta ); - - return PreCompose( cat, InjectionOfCofactorOfDirectSum( cat, [ Range( alpha ), Range( beta ) ], 2 ), direct_sum_morphism ); - - end -], -[ - UniversalMorphismFromWeakBiPushout, - [ [ UniversalMorphismFromDirectSum, 1 ], - [ DirectSum, 1 ], - [ PreCompose, 2 ], - [ InjectionOfCofactorOfDirectSumWithGivenDirectSum, 2 ], - [ SubtractionForMorphisms, 1 ], - [ WeakCokernelColift, 1 ] ], - function( cat, alpha, beta, test_mor_1, test_mor_2 ) - local test_mor, direct_sum_diagram, direct_sum, alpha_inj1, beta_inj2, difference; - - test_mor := UniversalMorphismFromDirectSum( cat, [ test_mor_1, test_mor_2 ] ); - - direct_sum_diagram := [ Range( alpha ), Range( beta ) ]; - - direct_sum := DirectSum( cat, direct_sum_diagram ); - - alpha_inj1 := PreCompose( cat, alpha, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 1, direct_sum ) ); - - beta_inj2 := PreCompose( cat, beta, InjectionOfCofactorOfDirectSumWithGivenDirectSum( cat, direct_sum_diagram, 2, direct_sum ) ); - - difference := SubtractionForMorphisms( cat, alpha_inj1, beta_inj2 ); - - return WeakCokernelColift( cat, difference, test_mor ); - - end -] ); - -## Final derivation for biased weak fiber products and biased weak pushouts. -## Decision: we use a derivation from weak fiber products and weak pushouts - -## -AddFinalDerivation( ProjectionOfBiasedWeakFiberProduct, - "ProjectionOfBiasedWeakFiberProduct using ProjectionInFirstFactorOfWeakBiFiberProduct", - [ [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ] ], - [ - BiasedWeakFiberProduct, - ProjectionOfBiasedWeakFiberProduct, - ], - - function( cat, alpha, beta ) - - return ProjectionInFirstFactorOfWeakBiFiberProduct( cat, alpha, beta ); - -end ); - -## -AddFinalDerivation( InjectionOfBiasedWeakPushout, - "ProjectioInjectionOfBiasedWeakPushoutnOfBiasedWeakFiberProduct using InjectionOfFirstCofactorOfWeakBiPushout", - [ [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ] ], - [ - BiasedWeakPushout, - InjectionOfBiasedWeakPushout, - ], - - function( cat, alpha, beta ) - - return InjectionOfFirstCofactorOfWeakBiPushout( cat, alpha, beta ); - -end ); diff --git a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gd b/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gd index f36fd638f0..a7cddc078b 100644 --- a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gd +++ b/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gd @@ -7,567 +7,6 @@ DeclareGlobalVariable( "FREYD_CATEGORIES_METHOD_NAME_RECORD" ); -DeclareGlobalFunction( "WEAK_BI_FIBER_PRODUCT_PREFUNCTION" ); - -DeclareGlobalFunction( "UNIVERSAL_MORPHISM_INTO_WEAK_BI_FIBER_PRODUCT_PREFUNCTION" ); - -DeclareGlobalFunction( "WEAK_BI_PUSHOUT_PREFUNCTION" ); - -DeclareGlobalFunction( "UNIVERSAL_MORPHISM_FROM_WEAK_BI_PUSHOUT_PREFUNCTION" ); - -DeclareGlobalFunction( "UNIVERSAL_MORPHISM_INTO_BIASED_WEAK_FIBER_PRODUCT_PREFUNCTION" ); - -DeclareGlobalFunction( "UNIVERSAL_MORPHISM_FROM_BIASED_WEAK_PUSHOUT_PREFUNCTION" ); - -##TODO: Adjust documentation - -#################################### -## -#! @Section Weak kernel -## -#################################### - -#! For a given morphism $\alpha: A \rightarrow B$, a weak kernel of $\alpha$ consists of three parts: -#! * an object $K$, -#! * a morphism $\iota: K \rightarrow A$ such that $\alpha \circ \iota \sim_{K,B} 0$, -#! * a dependent function $u$ mapping each morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$ to a morphism $u(\tau): T \rightarrow K$ such that $\iota \circ u( \tau ) \sim_{T,A} \tau$. -#! The triple $( K, \iota, u )$ is called a weak kernel of $\alpha$. -#! We denote the object $K$ of such a triple by $\mathrm{WeakKernelObject}(\alpha)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the weak kernel. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (T) at (-\w,\w) {$T$}; -#! \node (K) at (-\w,0) {$K$}; -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (K) to node[pos=0.45, above] {$\iota$} (A); -#! \draw[-latex] (T) to node[pos=0.45, above right] {$\tau$} (A); -#! \draw[-latex] (T) to node[pos=0.45, left] {$\exists u( \tau )$} (K); -#! \draw[-latex, dotted] (T) to [out = 0, in = 90] node[pos=0.45, above right] {$\alpha \circ \tau \sim_{T,B} 0$} (B); -#! \draw[-latex, dotted] (K) to [out = -45, in = -135] node[pos=0.45, below] {$\alpha \circ \iota \sim_{K,B} 0$} (B); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - -## Main Operations and Attributes -#! @Description -#! The argument is a morphism $\alpha$. -#! The output is the weak kernel $K$ of $\alpha$. -#! @Returns an object -#! @Arguments alpha -DeclareAttribute( "WeakKernelObject", - IsCapCategoryMorphism ); - -#! @Description -#! The argument is a morphism $\alpha: A \rightarrow B$. -#! The output is the weak kernel embedding $\iota: \mathrm{WeakKernelObject}(\alpha) \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}(\mathrm{WeakKernelObject}(\alpha),A)$ -#! @Arguments alpha -DeclareAttribute( "WeakKernelEmbedding", - IsCapCategoryMorphism ); - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$ -#! and an object $K = \mathrm{WeakKernelObject}(\alpha)$. -#! The output is the weak kernel embedding $\iota: K \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}(K,A)$ -#! @Arguments alpha, K -DeclareOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", - [ IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$ -#! and a test morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$. -#! The output is the morphism $u(\tau): T \rightarrow \mathrm{WeakKernelObject}(\alpha)$ -#! given by the universal property of the weak kernel. -#! @Returns a morphism in $\mathrm{Hom}(T,\mathrm{WeakKernelObject}(\alpha))$ -#! @Arguments alpha, tau -DeclareOperation( "WeakKernelLift", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$, -#! a test morphism $\tau: T \rightarrow A$ satisfying $\alpha \circ \tau \sim_{T,B} 0$, -#! and an object $K = \mathrm{WeakKernelObject}(\alpha)$. -#! The output is the morphism $u(\tau): T \rightarrow K$ -#! given by the universal property of the weak kernel. -#! @Returns a morphism in $\mathrm{Hom}(T,K)$ -#! @Arguments alpha, tau, K -DeclareOperation( "WeakKernelLiftWithGivenWeakKernelObject", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#################################### -## -#! @Section Weak cokernel -## -#################################### - -#! For a given morphism $\alpha: A \rightarrow B$, a weak cokernel of $\alpha$ consists of three parts: -#! * an object $K$, -#! * a morphism $\epsilon: B \rightarrow K$ such that $\epsilon \circ \alpha \sim_{A,K} 0$, -#! * a dependent function $u$ mapping each $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$ to a morphism $u(\tau):K \rightarrow T$ such that $u(\tau) \circ \epsilon \sim_{B,T} \tau$. -#! The triple $( K, \epsilon, u )$ is called a weak cokernel of $\alpha$. -#! We denote the object $K$ of such a triple by $\mathrm{WeakCokernelObject}(\alpha)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the weak cokernel. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \node (K) at (2*\w,0) {$K$}; -#! \node (T) at (2*\w,\w) {$T$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (B) to node[pos=0.45, above] {$\epsilon$} (K); -#! \draw[-latex] (B) to node[pos=0.45, above left] {$\tau$} (T); -#! \draw[-latex] (K) to node[pos=0.45, right] {$\exists u( \tau )$} (T); -#! \draw[-latex, dotted] (A) to [out = 90, in = 180] node[pos=0.45, above left] {$\tau \circ \alpha \sim_{A,T} 0$} (T); -#! \draw[-latex, dotted] (A) to [out = -45, in = -135] node[pos=0.45, below] {$\epsilon \circ \alpha \sim_{A,K} 0$} (K); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - - -## Main Operations and Attributes -#! @Description -#! The argument is a morphism $\alpha: A \rightarrow B$. -#! The output is the weak cokernel $K$ of $\alpha$. -#! @Returns an object -#! @Arguments alpha -DeclareAttribute( "WeakCokernelObject", - IsCapCategoryMorphism ); - -#! @Description -#! The argument is a morphism $\alpha: A \rightarrow B$. -#! The output is the weak cokernel projection $\epsilon: B \rightarrow \mathrm{WeakCokernelObject}( \alpha )$. -#! @Returns a morphism in $\mathrm{Hom}(B, \mathrm{WeakCokernelObject}( \alpha ))$ -#! @Arguments alpha -DeclareAttribute( "WeakCokernelProjection", - IsCapCategoryMorphism ); - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$ -#! and an object $K = \mathrm{WeakCokernelObject}(\alpha)$. -#! The output is the weak cokernel projection $\epsilon: B \rightarrow \mathrm{WeakCokernelObject}( \alpha )$. -#! @Returns a morphism in $\mathrm{Hom}(B, K)$ -#! @Arguments alpha, K -DeclareOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", - [ IsCapCategoryMorphism, IsCapCategoryObject ] ); - - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$ -#! and a test morphism $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$. -#! The output is the morphism $u(\tau): \mathrm{WeakCokernelObject}(\alpha) \rightarrow T$ -#! given by the universal property of the weak cokernel. -#! @Returns a morphism in $\mathrm{Hom}(\mathrm{WeakCokernelObject}(\alpha),T)$ -#! @Arguments alpha, tau -DeclareOperation( "WeakCokernelColift", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are a morphism $\alpha: A \rightarrow B$, -#! a test morphism $\tau: B \rightarrow T$ satisfying $\tau \circ \alpha \sim_{A, T} 0$, -#! and an object $K = \mathrm{WeakCokernelObject}(\alpha)$. -#! The output is the morphism $u(\tau): K \rightarrow T$ -#! given by the universal property of the weak cokernel. -#! @Returns a morphism in $\mathrm{Hom}(K,T)$ -#! @Arguments alpha, tau, K -DeclareOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#################################### -## -#! @Section Weak bi-fiber product -## -#################################### - -#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon C \rightarrow B)$, a weak bi-fiber product of $(\alpha, \beta)$ consists of three parts: -#! * an object $P$, -#! * morphisms $\pi_1: P \rightarrow A$, $\pi_2: P \rightarrow B$ such that $\alpha \circ \pi_1 \sim_{P,B} \beta \circ \pi_2$, -#! * a dependent function $u$ mapping each pair $\tau = ( \tau_1, \tau_2 )$ of morphisms $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$ with the property $\alpha \circ \tau_1 \sim_{T,B} \beta \circ \tau_2$ to a morphism $u(\tau):T \rightarrow P$ such that $\pi_1 \circ u( \tau ) \sim_{A,T} \tau_1$ and $\pi_2 \circ u( \tau ) \sim_{C,T} \tau_2$. -#! The quadrupel $( P, \pi_1, \pi_2, u )$ is called a weak bi-fiber product of $(\alpha,\beta)$. -#! We denote the object $P$ of such a quadrupel by $\mathrm{WeakBiFiberProduct}(\alpha,\beta)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the weak bi-fiber product. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \node (C) at (\w,\w) {$C$}; -#! \node (P) at (0,\w) {$P$}; -#! \node (T) at (-\w,2*\w) {$T$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (C) to node[pos=0.45, right] {$\beta$} (B); -#! \draw[-latex] (P) to node[pos=0.45, left] {$\pi_1$} (A); -#! \draw[-latex] (P) to node[pos=0.45, above] {$\pi_2$} (C); -#! \draw[-latex] (T) to [out = -90, in = 180] node[pos=0.45, left] {$\tau_1$} (A); -#! \draw[-latex] (T) to [out = 0, in = 90] node[pos=0.45, above] {$\tau_2$} (C); -#! \draw[-latex] (T) to node[pos=0.45, above right] {$\exists u( \tau )$} (P); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - -## Main Operations and Attributes - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the weak bi-fiber product $P$ of $\alpha$ and $\beta$. -#! @Returns an object -#! @Arguments alpha, beta -DeclareOperation( "WeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the first weak bi-fiber product projection $\pi_1: P \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}( P, A )$ -#! @Arguments alpha, beta -DeclareOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$ -#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. -#! The output is the first weak bi-fiber product projection $\pi_1: P \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}( P, A )$ -#! @Arguments alpha, beta, P -DeclareOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the second weak bi-fiber product projection $\pi_2: P \rightarrow C$. -#! @Returns a morphism in $\mathrm{Hom}( P, C )$ -#! @Arguments alpha, beta -DeclareOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$ -#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. -#! The output is the second weak bi-fiber product projection $\pi_2: P \rightarrow C$. -#! @Returns a morphism in $\mathrm{Hom}( P, C )$ -#! @Arguments alpha, beta, P -DeclareOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, -#! $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-fiber product -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( T, P )$ -#! @Arguments alpha, beta, tau_1, tau_2 -DeclareOperation( "UniversalMorphismIntoWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, -#! $\tau_1: T \rightarrow A$, $\tau_2: T \rightarrow C$ -#! and an object $P = \mathrm{WeakBiFiberProduct}( \alpha, \beta )$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-fiber product -#! $P$. -#! @Returns a morphism in $\mathrm{Hom}( T, P )$ -#! @Arguments alpha, beta, tau_1, tau_2, P -DeclareOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the morphism $P \rightarrow A \oplus C$ obtained -#! from the two weak bi-fiber product projections $\pi_1$ and $\pi_2$ and -#! the universal property of the direct sum. -#! @Returns a morphism in $\mathrm{Hom}( P, A \oplus C )$ -#! @Arguments alpha, beta -DeclareOperation( "WeakBiFiberProductMorphismToDirectSum", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#################################### -## -#! @Section Biased weak fiber product -## -#################################### - -#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon C \rightarrow B)$, a biased weak fiber product of $(\alpha, \beta)$ consists of three parts: -#! * an object $P$, -#! * a morphism $\pi: P \rightarrow A$ such that there exists a morphism $\delta: P \rightarrow C$ such that $\beta \circ \delta \sim_{P,B} \alpha \circ \pi$, -#! * a dependent function $u$ mapping each $\tau: T \rightarrow A$, which admits a morphism $\mu \colon T \rightarrow C$ with $\beta \circ \mu \sim_{T,B} \alpha \circ \tau$, to a morphism $u(\tau):T \rightarrow P$ such that $\pi \circ u(\tau) \sim_{T,A} \tau$. -#! The triple $( P, \pi, u )$ is called a biased weak fiber product of $(\alpha,\beta)$. -#! We denote the object $P$ of such a triple by $\mathrm{BiasedWeakFiberProduct}(\alpha,\beta)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the biased weak fiber product. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \node (C) at (\w,\w) {$C$}; -#! \node (P) at (0,\w) {$P$}; -#! \node (T) at (-\w,2*\w) {$T$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (C) to node[pos=0.45, right] {$\beta$} (B); -#! \draw[-latex] (P) to node[pos=0.45, left] {$\pi$} (A); -#! \draw[-latex] (T) to [out = -90, in = 180] node[pos=0.45, left] {$\tau$} (A); -#! \draw[-latex] (T) to node[pos=0.45, above right] {$\exists u( \tau )$} (P); -#! \draw[-latex, dotted] (P) to node[pos=0.45, above] {$\delta$} (C); -#! \draw[-latex, dotted] (T) to [out = 0, in = 90] node[pos=0.45, above] {$\mu$} (C); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - - -## Main Operations and Attributes - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the biased weak fiber product $P$ of $\alpha$ and $\beta$. -#! @Returns an object -#! @Arguments alpha, beta -DeclareOperation( "BiasedWeakFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -## corresponds to projection in 1st factor -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the biased weak fiber product projection $\pi: P \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}( P, A )$ -#! @Arguments alpha, beta -DeclareOperation( "ProjectionOfBiasedWeakFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, -#! and an object $P = \mathrm{BiasedWeakFiberProduct}( \alpha, \beta )$. -#! The output is the biased weak fiber product projection $\pi: P \rightarrow A$. -#! @Returns a morphism in $\mathrm{Hom}( P, A )$ -#! @Arguments alpha, beta, P -DeclareOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, -#! $\tau: T \rightarrow A$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak fiber product -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( T, P )$ -#! @Arguments alpha, beta, tau -DeclareOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$, -#! $\tau: T \rightarrow A$ -#! and an object $P = \mathrm{BiasedWeakFiberProduct}( \alpha, \beta )$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak fiber product -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( T, P )$ -#! @Arguments alpha, beta, tau, P -DeclareOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#################################### -## -#! @Section Weak bi-pushout -## -#################################### - -#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta \colon A \rightarrow C)$, a weak bi-pushout of $(\alpha, \beta)$ consists of three parts: -#! * an object $P$, -#! * morphisms $\iota_1: B \rightarrow P$, $\iota_2: C \rightarrow P$ such that $\iota_1 \circ \alpha \sim_{A,P} \iota_2 \circ \beta$, -#! * a dependent function $u$ mapping each pair $\tau = (\tau_1, \tau_2)$ of morphisms $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$ with the property $\tau_1 \circ \alpha \sim_{A,T} \tau_2 \circ \beta$ to a morphism $u(\tau): P \rightarrow T$ such that $u( \tau ) \circ \iota_1 \sim_{B,T} \tau_1$ and $u( \tau ) \circ \iota_2 \sim_{C,T} \tau_2$. -#! The quadrupel $( P, \iota_1, \iota_2, u )$ is called a weak bi-pushout of $(\alpha,\beta)$. -#! We denote the object $P$ of such a quadrupel by $\mathrm{WeakBiPushout}(\alpha,\beta)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the weak bi-pushout. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \node (C) at (0,\w) {$C$}; -#! \node (P) at (\w,\w) {$P$}; -#! \node (T) at (2*\w,2*\w) {$T$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (A) to node[pos=0.45, left] {$\beta$} (C); -#! \draw[-latex] (B) to node[pos=0.45, right] {$\iota_1$} (P); -#! \draw[-latex] (B) to [out = 0, in = -90] node[pos=0.45, right] {$\tau_1$} (T); -#! \draw[-latex] (P) to node[pos=0.45, above left] {$\exists u( \tau )$} (T); -#! \draw[-latex] (C) to node[pos=0.45, above] {$\iota_2$} (P); -#! \draw[-latex] (C) to [out = 90, in = 180] node[pos=0.45, above] {$\tau_2$} (T); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. -#! The output is the weak bi-pushout $P$ of $\alpha$ and $\beta$. -#! @Returns an object -#! @Arguments alpha, beta -DeclareOperation( "WeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. -#! The output is the first weak bi-pushout injection $\iota_1: B \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( B, P )$ -#! @Arguments alpha, beta -DeclareOperation( "InjectionOfFirstCofactorOfWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. -#! The output is the second weak bi-pushout injection $\iota_2: C \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( C, P )$ -#! @Arguments alpha, beta -DeclareOperation( "InjectionOfSecondCofactorOfWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ -#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. -#! The output is the first weak bi-pushout injection $\iota_1: B \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( B, P )$ -#! @Arguments alpha, beta, P -DeclareOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ -#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. -#! The output is the second weak bi-pushout injection $\iota_2: C \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( C, P )$ -#! @Arguments alpha, beta, P -DeclareOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, -#! $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-pushout -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( P, T )$ -#! @Arguments alpha, beta, tau_1, tau_2 -DeclareOperation( "UniversalMorphismFromWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are four morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, -#! $\tau_1: B \rightarrow T$, $\tau_2: C \rightarrow T$, -#! and an object $P = \mathrm{WeakBiPushout}( \alpha, \beta )$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the weak bi-pushout -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( P, T )$ -#! @Arguments alpha, beta, tau_1, tau_2, P -DeclareOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: C \rightarrow B$. -#! The output is the morphism $B \oplus C \rightarrow P$ obtained -#! from the two weak bi-fiber product injections $\iota_1$ and $\iota_2$ and -#! the universal property of the direct sum. -#! @Returns a morphism in $\mathrm{Hom}(B \oplus C, P )$ -#! @Arguments alpha, beta -DeclareOperation( "DirectSumMorphismToWeakBiPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#################################### -## -#! @Section Biased weak pushout -## -#################################### - -#! For a given pair of morphisms $(\alpha: A \rightarrow B, \beta: A \rightarrow C)$, a biased weak pushout of $(\alpha, \beta)$ consists of three parts: -#! * an object $P$, -#! * a morphism $\iota: B \rightarrow P$ such that there exists a morphism $\delta: C \rightarrow P$ such that $\delta \circ \beta \sim_{A,P} \iota \circ \alpha$, -#! * a dependent function $u$ mapping each $\tau: B \rightarrow T$, which admits a morphism $\mu \colon C \rightarrow T$ with $\mu \circ \beta \sim_{B,T} \tau \circ \alpha$, to a morphism $u(\tau):P \rightarrow T$ such that $u(\tau) \circ \iota \sim_{A,T} \tau$. -#! The triple $( P, \iota, u )$ is called a biased weak pushout of $(\alpha,\beta)$. -#! We denote the object $P$ of such a triple by $\mathrm{BiasedWeakPushout}(\alpha,\beta)$. -#! We say that the morphism $u(\tau)$ is induced by the -#! universal property of the biased weak pushout. - -#! @BeginLatexOnly -#! \begin{center} -#! \begin{tikzpicture} -#! \def\w{2} -#! \node (A) at (0,0) {$A$}; -#! \node (B) at (\w,0) {$B$}; -#! \node (C) at (0,\w) {$C$}; -#! \node (P) at (\w,\w) {$P$}; -#! \node (T) at (2*\w,2*\w) {$T$}; -#! \draw[-latex] (A) to node[pos=0.45, above] {$\alpha$} (B); -#! \draw[-latex] (A) to node[pos=0.45, left] {$\beta$} (C); -#! \draw[-latex] (B) to node[pos=0.45, right] {$\iota$} (P); -#! \draw[-latex] (B) to [out = 0, in = -90] node[pos=0.45, right] {$\tau$} (T); -#! \draw[-latex] (P) to node[pos=0.45, above left] {$\exists u( \tau )$} (T); -#! \draw[-latex, dotted] (C) to node[pos=0.45, above] {$\delta$} (P); -#! \draw[-latex, dotted] (C) to [out = 90, in = 180] node[pos=0.45, above] {$\mu$} (T); -#! \end{tikzpicture} -#! \end{center} -#! @EndLatexOnly - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. -#! The output is the biased weak pushout $P$ of $\alpha$ and $\beta$. -#! @Returns an object -#! @Arguments alpha, beta -DeclareOperation( "BiasedWeakPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$. -#! The output is the biased weak pushout injection $\iota: B \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( B, P )$ -#! @Arguments alpha, beta -DeclareOperation( "InjectionOfBiasedWeakPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are two morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$ -#! and an object $P = \mathrm{BiasedWeakPushout}( \alpha, \beta )$. -#! The output is the biased weak pushout injection $\iota: B \rightarrow P$. -#! @Returns a morphism in $\mathrm{Hom}( B, P )$ -#! @Arguments alpha, beta, P -DeclareOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - -#! @Description -#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, -#! $\tau: B \rightarrow T$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak pushout -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( P, T )$ -#! @Arguments alpha, beta, tau -DeclareOperation( "UniversalMorphismFromBiasedWeakPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism ] ); - -#! @Description -#! The arguments are three morphisms $\alpha: A \rightarrow B$, $\beta: A \rightarrow C$, -#! $\tau: B \rightarrow T$ -#! and an object $P = \mathrm{BiasedWeakPushout}( \alpha, \beta )$. -#! The output is the morphism $u( \tau )$ induced by the universal property of the biased weak pushout -#! $P$ of $\alpha$ and $\beta$. -#! @Returns a morphism in $\mathrm{Hom}( P, T )$ -#! @Arguments alpha, beta, tau, P -DeclareOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryMorphism, IsCapCategoryObject ] ); - #################################### ## #! @Section Abelian constructions diff --git a/FreydCategoriesForCAP/gap/FreydCategoriesMethodRecord.gi b/FreydCategoriesForCAP/gap/FreydCategoriesMethodRecord.gi new file mode 100644 index 0000000000..2900094f2d --- /dev/null +++ b/FreydCategoriesForCAP/gap/FreydCategoriesMethodRecord.gi @@ -0,0 +1,130 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# FreydCategoriesForCAP: Freyd categories - Formal (co)kernels for additive categories +# +# Implementations +# + +InstallValue( FREYD_CATEGORIES_METHOD_NAME_RECORD, rec( + +## an abelian construction +SomeProjectiveObjectForKernelObject := rec( + filter_list := [ "category", "morphism" ], + return_type := "object", + dual_operation := "SomeInjectiveObjectForCokernelObject", + is_merely_set_theoretic := true ), + +EpimorphismFromSomeProjectiveObjectForKernelObject := rec( + filter_list := [ "category", "morphism" ], + input_arguments_names := [ "cat", "alpha" ], + with_given_object_position := "Source", + output_range_getter_string := "KernelObject( cat, alpha )", + output_range_getter_preconditions := [ [ "KernelObject", 1 ] ], + return_type := "morphism", + dual_operation := "MonomorphismToSomeInjectiveObjectForCokernelObject", + is_merely_set_theoretic := true ), + +EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject := rec( + filter_list := [ "category", "morphism", "object" ], + input_arguments_names := [ "cat", "alpha", "source" ], + return_type := "morphism", + output_source_getter_string := "source", + output_range_getter_string := "KernelObject( cat, alpha )", + output_range_getter_preconditions := [ [ "KernelObject", 1 ] ], + dual_operation := "MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject", + is_merely_set_theoretic := true ), + +SomeInjectiveObjectForCokernelObject := rec( + filter_list := [ "category", "morphism" ], + return_type := "object", + dual_operation := "SomeProjectiveObjectForKernelObject", + is_merely_set_theoretic := true ), + +MonomorphismToSomeInjectiveObjectForCokernelObject := rec( + filter_list := [ "category", "morphism" ], + input_arguments_names := [ "cat", "alpha" ], + output_source_getter_string := "CokernelObject( cat, alpha )", + output_source_getter_preconditions := [ [ "CokernelObject", 1 ] ], + with_given_object_position := "Range", + return_type := "morphism", + dual_operation := "EpimorphismFromSomeProjectiveObjectForKernelObject", + is_merely_set_theoretic := true ), + +MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject := rec( + filter_list := [ "category", "morphism", "object" ], + input_arguments_names := [ "cat", "alpha", "range" ], + return_type := "morphism", + output_source_getter_string := "CokernelObject( cat, alpha )", + output_source_getter_preconditions := [ [ "CokernelObject", 1 ] ], + output_range_getter_string := "range", + dual_operation := "EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject", + is_merely_set_theoretic := true ), + + ) ); + +CAP_INTERNAL_ENHANCE_NAME_RECORD( FREYD_CATEGORIES_METHOD_NAME_RECORD ); + +CAP_INTERNAL_GENERATE_DECLARATIONS_AND_INSTALLATIONS_FROM_METHOD_NAME_RECORD( + FREYD_CATEGORIES_METHOD_NAME_RECORD, + "FreydCategoriesForCAP", + "MethodRecord", + "Add Functions", + "Available Add functions" +); + +CAP_INTERNAL_REGISTER_METHOD_NAME_RECORD_OF_PACKAGE( FREYD_CATEGORIES_METHOD_NAME_RECORD, "FreydCategoriesForCAP" ); + +CAP_INTERNAL_INSTALL_ADDS_FROM_RECORD( FREYD_CATEGORIES_METHOD_NAME_RECORD ); + +#################################### +## +## Free abelian category +## +#################################### + +InstallMethod( AsMorphismInFreeAbelianCategory, + [ IsCapCategoryMorphism ], + + function( morphism ) + + return Opposite( + AsFreydCategoryMorphism( + Opposite( + AsFreydCategoryMorphism( + AsAdditiveClosureMorphism( morphism ) + ) + ) + ) + ); + +end ); + +################################### +## +## Finitely presented functors +## +#################################### + +## +InstallMethod( CovariantExtAsFreydCategoryObject, + [ IsCapCategoryObject, IsInt ], + + function( object, i ) + local morphism, j; + + if i = 0 then + + return AsFreydCategoryObject( Opposite( object ) ); + + fi; + + morphism := EpimorphismFromSomeProjectiveObject( object ); + + for j in [ 2 .. i ] do + + morphism := EpimorphismFromSomeProjectiveObjectForKernelObject( morphism ); + + od; + + return FreydCategoryObject( Opposite( KernelEmbedding( morphism ) ) ); + +end ); diff --git a/FreydCategoriesForCAP/gap/MethodRecordDeclarations.autogen.gd b/FreydCategoriesForCAP/gap/MethodRecordDeclarations.autogen.gd index 05728f3a40..5537b7cf65 100644 --- a/FreydCategoriesForCAP/gap/MethodRecordDeclarations.autogen.gd +++ b/FreydCategoriesForCAP/gap/MethodRecordDeclarations.autogen.gd @@ -9,63 +9,6 @@ #! @Section Available Add functions -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `BiasedWeakFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2, arg3 ) \mapsto \mathtt{BiasedWeakFiberProduct}(arg2, arg3)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `BiasedWeakPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2, arg3 ) \mapsto \mathtt{BiasedWeakPushout}(arg2, arg3)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddBiasedWeakPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddBiasedWeakPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `DirectSumMorphismToWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, beta ) \mapsto \mathtt{DirectSumMorphismToWeakBiPushout}(alpha, beta)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddDirectSumMorphismToWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddDirectSumMorphismToWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - #! @BeginGroup #! @Description #! The arguments are a category $C$ and a function $F$. @@ -104,120 +47,6 @@ DeclareOperation( "AddEpimorphismFromSomeProjectiveObjectForKernelObjectWithGive #! @EndGroup -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfBiasedWeakPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{InjectionOfBiasedWeakPushout}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfBiasedWeakPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfBiasedWeakPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfFirstCofactorOfWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{InjectionOfFirstCofactorOfWeakBiPushout}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfSecondCofactorOfWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{InjectionOfSecondCofactorOfWeakBiPushout}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - #! @BeginGroup #! @Description #! The arguments are a category $C$ and a function $F$. @@ -256,120 +85,6 @@ DeclareOperation( "AddMonomorphismToSomeInjectiveObjectForCokernelObjectWithGive #! @EndGroup -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionInFirstFactorOfWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{ProjectionInFirstFactorOfWeakBiFiberProduct}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionInSecondFactorOfWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{ProjectionInSecondFactorOfWeakBiFiberProduct}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionOfBiasedWeakFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b ) \mapsto \mathtt{ProjectionOfBiasedWeakFiberProduct}(a, b)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionOfBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionOfBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, P ) \mapsto \mathtt{ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct}(a, b, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - #! @BeginGroup #! @Description #! The arguments are a category $C$ and a function $F$. @@ -407,402 +122,3 @@ DeclareOperation( "AddSomeProjectiveObjectForKernelObject", [ IsCapCategory, IsFunction, IsInt ] ); #! @EndGroup - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismFromBiasedWeakPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t ) \mapsto \mathtt{UniversalMorphismFromBiasedWeakPushout}(a, b, t)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, P ) \mapsto \mathtt{UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout}(a, b, t, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismFromWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, s ) \mapsto \mathtt{UniversalMorphismFromWeakBiPushout}(a, b, t, s)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismFromWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismFromWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, s, P ) \mapsto \mathtt{UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout}(a, b, t, s, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismIntoBiasedWeakFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t ) \mapsto \mathtt{UniversalMorphismIntoBiasedWeakFiberProduct}(a, b, t)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, P ) \mapsto \mathtt{UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct}(a, b, t, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismIntoWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, s ) \mapsto \mathtt{UniversalMorphismIntoWeakBiFiberProduct}(a, b, t, s)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( a, b, t, s, P ) \mapsto \mathtt{UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct}(a, b, t, s, P)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakBiFiberProduct`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2, arg3 ) \mapsto \mathtt{WeakBiFiberProduct}(arg2, arg3)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakBiFiberProduct", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakBiFiberProduct", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakBiFiberProductMorphismToDirectSum`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, beta ) \mapsto \mathtt{WeakBiFiberProductMorphismToDirectSum}(alpha, beta)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakBiFiberProductMorphismToDirectSum", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakBiFiberProductMorphismToDirectSum", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakBiPushout`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2, arg3 ) \mapsto \mathtt{WeakBiPushout}(arg2, arg3)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakBiPushout", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakBiPushout", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakCokernelColift`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, tau ) \mapsto \mathtt{WeakCokernelColift}(alpha, tau)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakCokernelColift", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakCokernelColift", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakCokernelColiftWithGivenWeakCokernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, tau, K ) \mapsto \mathtt{WeakCokernelColiftWithGivenWeakCokernelObject}(alpha, tau, K)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakCokernelColiftWithGivenWeakCokernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakCokernelColiftWithGivenWeakCokernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakCokernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2 ) \mapsto \mathtt{WeakCokernelObject}(arg2)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakCokernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakCokernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakCokernelProjection`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha ) \mapsto \mathtt{WeakCokernelProjection}(alpha)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakCokernelProjection", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakCokernelProjection", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakCokernelProjectionWithGivenWeakCokernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, K ) \mapsto \mathtt{WeakCokernelProjectionWithGivenWeakCokernelObject}(alpha, K)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakCokernelProjectionWithGivenWeakCokernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakCokernelProjectionWithGivenWeakCokernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakKernelEmbedding`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha ) \mapsto \mathtt{WeakKernelEmbedding}(alpha)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakKernelEmbedding", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakKernelEmbedding", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakKernelEmbeddingWithGivenWeakKernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, K ) \mapsto \mathtt{WeakKernelEmbeddingWithGivenWeakKernelObject}(alpha, K)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakKernelEmbeddingWithGivenWeakKernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakKernelEmbeddingWithGivenWeakKernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakKernelLift`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, tau ) \mapsto \mathtt{WeakKernelLift}(alpha, tau)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakKernelLift", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakKernelLift", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakKernelLiftWithGivenWeakKernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( alpha, tau, K ) \mapsto \mathtt{WeakKernelLiftWithGivenWeakKernelObject}(alpha, tau, K)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakKernelLiftWithGivenWeakKernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakKernelLiftWithGivenWeakKernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - - -#! @BeginGroup -#! @Description -#! The arguments are a category $C$ and a function $F$. -#! This operation adds the given function $F$ -#! to the category for the basic operation `WeakKernelObject`. -#! Optionally, a weight (default: 100) can be specified which should roughly correspond -#! to the computational complexity of the function (lower weight = less complex = faster execution). -#! $F: ( arg2 ) \mapsto \mathtt{WeakKernelObject}(arg2)$. -#! @Returns nothing -#! @Arguments C, F -DeclareOperation( "AddWeakKernelObject", - [ IsCapCategory, IsFunction ] ); - -#! @Arguments C, F, weight -DeclareOperation( "AddWeakKernelObject", - [ IsCapCategory, IsFunction, IsInt ] ); -#! @EndGroup - diff --git a/FreydCategoriesForCAP/gap/MethodRecordInstallations.autogen.gi b/FreydCategoriesForCAP/gap/MethodRecordInstallations.autogen.gi index 5bba80e89a..fd1b6c77d9 100644 --- a/FreydCategoriesForCAP/gap/MethodRecordInstallations.autogen.gi +++ b/FreydCategoriesForCAP/gap/MethodRecordInstallations.autogen.gi @@ -5,81 +5,6 @@ # # THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi -## BiasedWeakFiberProduct -InstallMethod( AddBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "BiasedWeakFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "BiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## BiasedWeakPushout -InstallMethod( AddBiasedWeakPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "BiasedWeakPushout", category, func, -1 ); - -end ); - -InstallMethod( AddBiasedWeakPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "BiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## DirectSumMorphismToWeakBiPushout -InstallMethod( AddDirectSumMorphismToWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "DirectSumMorphismToWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddDirectSumMorphismToWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "DirectSumMorphismToWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - ## EpimorphismFromSomeProjectiveObjectForKernelObject InstallMethod( AddEpimorphismFromSomeProjectiveObjectForKernelObject, [ IsCapCategory, IsFunction ], @@ -153,225 +78,6 @@ AddDerivationToCAP( EpimorphismFromSomeProjectiveObjectForKernelObject, end : is_with_given_derivation := true ); -## InjectionOfBiasedWeakPushout -InstallMethod( AddInjectionOfBiasedWeakPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfBiasedWeakPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfBiasedWeakPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout -InstallMethod( AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, - "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout by calling InjectionOfBiasedWeakPushout with the WithGiven argument(s) dropped", - [ - [ InjectionOfBiasedWeakPushout, 1 ], - ], - function( cat, a, b, P ) - - return InjectionOfBiasedWeakPushout( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( InjectionOfBiasedWeakPushout, - "InjectionOfBiasedWeakPushout by calling InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout with the WithGiven object(s)", - [ - [ InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout, 1 ], - [ BiasedWeakPushout, 1 ], - ], - function( cat, a, b ) - - return InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout( cat, a, b, BiasedWeakPushout( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## InjectionOfFirstCofactorOfWeakBiPushout -InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout -InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout by calling InjectionOfFirstCofactorOfWeakBiPushout with the WithGiven argument(s) dropped", - [ - [ InjectionOfFirstCofactorOfWeakBiPushout, 1 ], - ], - function( cat, a, b, P ) - - return InjectionOfFirstCofactorOfWeakBiPushout( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( InjectionOfFirstCofactorOfWeakBiPushout, - "InjectionOfFirstCofactorOfWeakBiPushout by calling InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", - [ - [ InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout, 1 ], - [ WeakBiPushout, 1 ], - ], - function( cat, a, b ) - - return InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, WeakBiPushout( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## InjectionOfSecondCofactorOfWeakBiPushout -InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout -InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddInjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, - "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout by calling InjectionOfSecondCofactorOfWeakBiPushout with the WithGiven argument(s) dropped", - [ - [ InjectionOfSecondCofactorOfWeakBiPushout, 1 ], - ], - function( cat, a, b, P ) - - return InjectionOfSecondCofactorOfWeakBiPushout( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( InjectionOfSecondCofactorOfWeakBiPushout, - "InjectionOfSecondCofactorOfWeakBiPushout by calling InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", - [ - [ InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout, 1 ], - [ WeakBiPushout, 1 ], - ], - function( cat, a, b ) - - return InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, WeakBiPushout( cat, a, b ) ); - -end : is_with_given_derivation := true ); - ## MonomorphismToSomeInjectiveObjectForCokernelObject InstallMethod( AddMonomorphismToSomeInjectiveObjectForCokernelObject, [ IsCapCategory, IsFunction ], @@ -445,17 +151,17 @@ AddDerivationToCAP( MonomorphismToSomeInjectiveObjectForCokernelObject, end : is_with_given_derivation := true ); -## ProjectionInFirstFactorOfWeakBiFiberProduct -InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProduct, +## SomeInjectiveObjectForCokernelObject +InstallMethod( AddSomeInjectiveObjectForCokernelObject, [ IsCapCategory, IsFunction ], function( category, func ) - AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", category, func, -1 ); + AddCapOperation( "SomeInjectiveObjectForCokernelObject", category, func, -1 ); end ); -InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProduct, +InstallMethod( AddSomeInjectiveObjectForCokernelObject, [ IsCapCategory, IsFunction, IsInt ], FunctionWithNamedArguments( @@ -464,242 +170,23 @@ InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProduct, ], function( CAP_NAMED_ARGUMENTS, category, func, weight ) - AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + AddCapOperation( "SomeInjectiveObjectForCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); end ) ); -## ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct -InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, +## SomeProjectiveObjectForKernelObject +InstallMethod( AddSomeProjectiveObjectForKernelObject, [ IsCapCategory, IsFunction ], function( category, func ) - AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); + AddCapOperation( "SomeProjectiveObjectForKernelObject", category, func, -1 ); end ); -InstallMethod( AddProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, - "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct by calling ProjectionInFirstFactorOfWeakBiFiberProduct with the WithGiven argument(s) dropped", - [ - [ ProjectionInFirstFactorOfWeakBiFiberProduct, 1 ], - ], - function( cat, a, b, P ) - - return ProjectionInFirstFactorOfWeakBiFiberProduct( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( ProjectionInFirstFactorOfWeakBiFiberProduct, - "ProjectionInFirstFactorOfWeakBiFiberProduct by calling ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", - [ - [ ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], - [ WeakBiFiberProduct, 1 ], - ], - function( cat, a, b ) - - return ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, WeakBiFiberProduct( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## ProjectionInSecondFactorOfWeakBiFiberProduct -InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct -InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, - "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct by calling ProjectionInSecondFactorOfWeakBiFiberProduct with the WithGiven argument(s) dropped", - [ - [ ProjectionInSecondFactorOfWeakBiFiberProduct, 1 ], - ], - function( cat, a, b, P ) - - return ProjectionInSecondFactorOfWeakBiFiberProduct( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( ProjectionInSecondFactorOfWeakBiFiberProduct, - "ProjectionInSecondFactorOfWeakBiFiberProduct by calling ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", - [ - [ ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], - [ WeakBiFiberProduct, 1 ], - ], - function( cat, a, b ) - - return ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, WeakBiFiberProduct( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## ProjectionOfBiasedWeakFiberProduct -InstallMethod( AddProjectionOfBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "ProjectionOfBiasedWeakFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddProjectionOfBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "ProjectionOfBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct -InstallMethod( AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct by calling ProjectionOfBiasedWeakFiberProduct with the WithGiven argument(s) dropped", - [ - [ ProjectionOfBiasedWeakFiberProduct, 1 ], - ], - function( cat, a, b, P ) - - return ProjectionOfBiasedWeakFiberProduct( cat, a, b ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( ProjectionOfBiasedWeakFiberProduct, - "ProjectionOfBiasedWeakFiberProduct by calling ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct with the WithGiven object(s)", - [ - [ ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, 1 ], - [ BiasedWeakFiberProduct, 1 ], - ], - function( cat, a, b ) - - return ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct( cat, a, b, BiasedWeakFiberProduct( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## SomeInjectiveObjectForCokernelObject -InstallMethod( AddSomeInjectiveObjectForCokernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "SomeInjectiveObjectForCokernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddSomeInjectiveObjectForCokernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "SomeInjectiveObjectForCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## SomeProjectiveObjectForKernelObject -InstallMethod( AddSomeProjectiveObjectForKernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "SomeProjectiveObjectForKernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddSomeProjectiveObjectForKernelObject, +InstallMethod( AddSomeProjectiveObjectForKernelObject, [ IsCapCategory, IsFunction, IsInt ], FunctionWithNamedArguments( @@ -713,712 +200,3 @@ InstallMethod( AddSomeProjectiveObjectForKernelObject, end ) ); - -## UniversalMorphismFromBiasedWeakPushout -InstallMethod( AddUniversalMorphismFromBiasedWeakPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismFromBiasedWeakPushout", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismFromBiasedWeakPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismFromBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout -InstallMethod( AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, - "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout by calling UniversalMorphismFromBiasedWeakPushout with the WithGiven argument(s) dropped", - [ - [ UniversalMorphismFromBiasedWeakPushout, 1 ], - ], - function( cat, a, b, t, P ) - - return UniversalMorphismFromBiasedWeakPushout( cat, a, b, t ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( UniversalMorphismFromBiasedWeakPushout, - "UniversalMorphismFromBiasedWeakPushout by calling UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout with the WithGiven object(s)", - [ - [ UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout, 1 ], - [ BiasedWeakPushout, 1 ], - ], - function( cat, a, b, t ) - - return UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout( cat, a, b, t, BiasedWeakPushout( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## UniversalMorphismFromWeakBiPushout -InstallMethod( AddUniversalMorphismFromWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismFromWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismFromWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismFromWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout -InstallMethod( AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, - "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout by calling UniversalMorphismFromWeakBiPushout with the WithGiven argument(s) dropped", - [ - [ UniversalMorphismFromWeakBiPushout, 1 ], - ], - function( cat, a, b, t, s, P ) - - return UniversalMorphismFromWeakBiPushout( cat, a, b, t, s ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( UniversalMorphismFromWeakBiPushout, - "UniversalMorphismFromWeakBiPushout by calling UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout with the WithGiven object(s)", - [ - [ UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout, 1 ], - [ WeakBiPushout, 1 ], - ], - function( cat, a, b, t, s ) - - return UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout( cat, a, b, t, s, WeakBiPushout( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## UniversalMorphismIntoBiasedWeakFiberProduct -InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct -InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, - "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct by calling UniversalMorphismIntoBiasedWeakFiberProduct with the WithGiven argument(s) dropped", - [ - [ UniversalMorphismIntoBiasedWeakFiberProduct, 1 ], - ], - function( cat, a, b, t, P ) - - return UniversalMorphismIntoBiasedWeakFiberProduct( cat, a, b, t ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( UniversalMorphismIntoBiasedWeakFiberProduct, - "UniversalMorphismIntoBiasedWeakFiberProduct by calling UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct with the WithGiven object(s)", - [ - [ UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct, 1 ], - [ BiasedWeakFiberProduct, 1 ], - ], - function( cat, a, b, t ) - - return UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct( cat, a, b, t, BiasedWeakFiberProduct( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## UniversalMorphismIntoWeakBiFiberProduct -InstallMethod( AddUniversalMorphismIntoWeakBiFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismIntoWeakBiFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismIntoWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismIntoWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct -InstallMethod( AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddUniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, - "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct by calling UniversalMorphismIntoWeakBiFiberProduct with the WithGiven argument(s) dropped", - [ - [ UniversalMorphismIntoWeakBiFiberProduct, 1 ], - ], - function( cat, a, b, t, s, P ) - - return UniversalMorphismIntoWeakBiFiberProduct( cat, a, b, t, s ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( UniversalMorphismIntoWeakBiFiberProduct, - "UniversalMorphismIntoWeakBiFiberProduct by calling UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct with the WithGiven object(s)", - [ - [ UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct, 1 ], - [ WeakBiFiberProduct, 1 ], - ], - function( cat, a, b, t, s ) - - return UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct( cat, a, b, t, s, WeakBiFiberProduct( cat, a, b ) ); - -end : is_with_given_derivation := true ); - -## WeakBiFiberProduct -InstallMethod( AddWeakBiFiberProduct, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakBiFiberProduct", category, func, -1 ); - -end ); - -InstallMethod( AddWeakBiFiberProduct, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakBiFiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakBiFiberProductMorphismToDirectSum -InstallMethod( AddWeakBiFiberProductMorphismToDirectSum, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakBiFiberProductMorphismToDirectSum", category, func, -1 ); - -end ); - -InstallMethod( AddWeakBiFiberProductMorphismToDirectSum, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakBiFiberProductMorphismToDirectSum", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakBiPushout -InstallMethod( AddWeakBiPushout, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakBiPushout", category, func, -1 ); - -end ); - -InstallMethod( AddWeakBiPushout, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakBiPushout", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakCokernelColift -InstallMethod( AddWeakCokernelColift, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakCokernelColift", category, func, -1 ); - -end ); - -InstallMethod( AddWeakCokernelColift, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakCokernelColift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakCokernelColiftWithGivenWeakCokernelObject -InstallMethod( AddWeakCokernelColiftWithGivenWeakCokernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakCokernelColiftWithGivenWeakCokernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakCokernelColiftWithGivenWeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( WeakCokernelColiftWithGivenWeakCokernelObject, - "WeakCokernelColiftWithGivenWeakCokernelObject by calling WeakCokernelColift with the WithGiven argument(s) dropped", - [ - [ WeakCokernelColift, 1 ], - ], - function( cat, alpha, tau, K ) - - return WeakCokernelColift( cat, alpha, tau ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( WeakCokernelColift, - "WeakCokernelColift by calling WeakCokernelColiftWithGivenWeakCokernelObject with the WithGiven object(s)", - [ - [ WeakCokernelColiftWithGivenWeakCokernelObject, 1 ], - [ WeakCokernelObject, 1 ], - ], - function( cat, alpha, tau ) - - return WeakCokernelColiftWithGivenWeakCokernelObject( cat, alpha, tau, WeakCokernelObject( cat, alpha ) ); - -end : is_with_given_derivation := true ); - -## WeakCokernelObject -InstallMethod( AddWeakCokernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakCokernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakCokernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakCokernelProjection -InstallMethod( AddWeakCokernelProjection, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakCokernelProjection", category, func, -1 ); - -end ); - -InstallMethod( AddWeakCokernelProjection, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakCokernelProjection", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakCokernelProjectionWithGivenWeakCokernelObject -InstallMethod( AddWeakCokernelProjectionWithGivenWeakCokernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakCokernelProjectionWithGivenWeakCokernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakCokernelProjectionWithGivenWeakCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( WeakCokernelProjectionWithGivenWeakCokernelObject, - "WeakCokernelProjectionWithGivenWeakCokernelObject by calling WeakCokernelProjection with the WithGiven argument(s) dropped", - [ - [ WeakCokernelProjection, 1 ], - ], - function( cat, alpha, K ) - - return WeakCokernelProjection( cat, alpha ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( WeakCokernelProjection, - "WeakCokernelProjection by calling WeakCokernelProjectionWithGivenWeakCokernelObject with the WithGiven object(s)", - [ - [ WeakCokernelProjectionWithGivenWeakCokernelObject, 1 ], - [ WeakCokernelObject, 1 ], - ], - function( cat, alpha ) - - return WeakCokernelProjectionWithGivenWeakCokernelObject( cat, alpha, WeakCokernelObject( cat, alpha ) ); - -end : is_with_given_derivation := true ); - -## WeakKernelEmbedding -InstallMethod( AddWeakKernelEmbedding, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakKernelEmbedding", category, func, -1 ); - -end ); - -InstallMethod( AddWeakKernelEmbedding, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakKernelEmbedding", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakKernelEmbeddingWithGivenWeakKernelObject -InstallMethod( AddWeakKernelEmbeddingWithGivenWeakKernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakKernelEmbeddingWithGivenWeakKernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakKernelEmbeddingWithGivenWeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( WeakKernelEmbeddingWithGivenWeakKernelObject, - "WeakKernelEmbeddingWithGivenWeakKernelObject by calling WeakKernelEmbedding with the WithGiven argument(s) dropped", - [ - [ WeakKernelEmbedding, 1 ], - ], - function( cat, alpha, K ) - - return WeakKernelEmbedding( cat, alpha ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( WeakKernelEmbedding, - "WeakKernelEmbedding by calling WeakKernelEmbeddingWithGivenWeakKernelObject with the WithGiven object(s)", - [ - [ WeakKernelEmbeddingWithGivenWeakKernelObject, 1 ], - [ WeakKernelObject, 1 ], - ], - function( cat, alpha ) - - return WeakKernelEmbeddingWithGivenWeakKernelObject( cat, alpha, WeakKernelObject( cat, alpha ) ); - -end : is_with_given_derivation := true ); - -## WeakKernelLift -InstallMethod( AddWeakKernelLift, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakKernelLift", category, func, -1 ); - -end ); - -InstallMethod( AddWeakKernelLift, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakKernelLift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -## WeakKernelLiftWithGivenWeakKernelObject -InstallMethod( AddWeakKernelLiftWithGivenWeakKernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakKernelLiftWithGivenWeakKernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakKernelLiftWithGivenWeakKernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakKernelLiftWithGivenWeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); - -AddDerivationToCAP( WeakKernelLiftWithGivenWeakKernelObject, - "WeakKernelLiftWithGivenWeakKernelObject by calling WeakKernelLift with the WithGiven argument(s) dropped", - [ - [ WeakKernelLift, 1 ], - ], - function( cat, alpha, tau, K ) - - return WeakKernelLift( cat, alpha, tau ); - -end : is_with_given_derivation := true ); - -AddDerivationToCAP( WeakKernelLift, - "WeakKernelLift by calling WeakKernelLiftWithGivenWeakKernelObject with the WithGiven object(s)", - [ - [ WeakKernelLiftWithGivenWeakKernelObject, 1 ], - [ WeakKernelObject, 1 ], - ], - function( cat, alpha, tau ) - - return WeakKernelLiftWithGivenWeakKernelObject( cat, alpha, tau, WeakKernelObject( cat, alpha ) ); - -end : is_with_given_derivation := true ); - -## WeakKernelObject -InstallMethod( AddWeakKernelObject, - [ IsCapCategory, IsFunction ], - - function( category, func ) - - AddCapOperation( "WeakKernelObject", category, func, -1 ); - -end ); - -InstallMethod( AddWeakKernelObject, - [ IsCapCategory, IsFunction, IsInt ], - - FunctionWithNamedArguments( - [ - [ "IsPrecompiledDerivation", false ], - ], - function( CAP_NAMED_ARGUMENTS, category, func, weight ) - - AddCapOperation( "WeakKernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); - - end - ) -); diff --git a/FreydCategoriesForCAP/init.g b/FreydCategoriesForCAP/init.g index ef5ab0c040..05bcc37489 100644 --- a/FreydCategoriesForCAP/init.g +++ b/FreydCategoriesForCAP/init.g @@ -8,27 +8,10 @@ ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategoriesForCAP.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/MethodRecordDeclarations.autogen.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfRows.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gd" ); - -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfColumns.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gd" ); - -# include the packages for graded rows and columns -#= comment for Julia -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/Tools.gd" ); -# =# - ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategory.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/CoFreydCategory.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/CoFreydCategory_as_Opposite_FreydCategory_Opposite.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/AdditiveClosure.gd" ); - ReadPackage( "FreydCategoriesForCAP", "gap/CokernelImageClosure.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/AdelmanCategory.gd" ); @@ -39,8 +22,6 @@ ReadPackage( "FreydCategoriesForCAP", "gap/LinearClosure.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/ProSetsAsCats.gd" ); -ReadPackage( "FreydCategoriesForCAP", "gap/RingsAsAbCats.gd" ); - ReadPackage( "FreydCategoriesForCAP", "gap/GradeFiltration.gd" ); ReadPackage( "FreydCategoriesForCAP", "gap/SerreSubcategoryFunctions.gd" ); diff --git a/FreydCategoriesForCAP/makedoc.g b/FreydCategoriesForCAP/makedoc.g index ab2b054e9f..87060d984a 100644 --- a/FreydCategoriesForCAP/makedoc.g +++ b/FreydCategoriesForCAP/makedoc.g @@ -12,7 +12,7 @@ fi; AutoDoc( rec( autodoc := rec( files := [ "doc/Doc.autodoc" ], - scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/CategoryOfGradedRowsAndColumns", "gap/GradedModulePresentationsByFreyd" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/GradedModulePresentationsByFreyd" ], ), extract_examples := rec( units := "Single", diff --git a/FreydCategoriesForCAP/makedoc_with_overfull_hbox_warnings.g b/FreydCategoriesForCAP/makedoc_with_overfull_hbox_warnings.g index 1a0fe1f852..9c54b56a6a 100644 --- a/FreydCategoriesForCAP/makedoc_with_overfull_hbox_warnings.g +++ b/FreydCategoriesForCAP/makedoc_with_overfull_hbox_warnings.g @@ -13,7 +13,7 @@ AutoDoc( rec( dir := "doc_tmp/", autodoc := rec( files := [ "doc/Doc.autodoc" ], - scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/CategoryOfGradedRowsAndColumns", "gap/GradedModulePresentationsByFreyd" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc", "gap/GradedModulePresentationsByFreyd" ], ), gapdoc := rec( LaTeXOptions := rec( diff --git a/FreydCategoriesForCAP/read.g b/FreydCategoriesForCAP/read.g index a30ecf1b47..ff398cd8f0 100644 --- a/FreydCategoriesForCAP/read.g +++ b/FreydCategoriesForCAP/read.g @@ -3,24 +3,10 @@ # # Reading the implementation part of the package. # -ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategoriesForCAP.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/MethodRecordInstallations.autogen.gi" ); - -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfRows.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfRows_as_AdditiveClosure_RingAsCategory.gi" ); +ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategoriesMethodRecord.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfColumns.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfColumns_as_Opposite_CategoryOfRows.gi" ); - -# include the packages for graded rows and columns -#= comment for Julia -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumn.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/GradedRowOrColumnMorphism.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedRows.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/CategoryOfGradedColumns.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/CategoryOfGradedRowsAndColumns/Tools.gi" ); -# =# +ReadPackage( "FreydCategoriesForCAP", "gap/MethodRecordInstallations.autogen.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategoriesDerivedMethods.gi" ); @@ -28,9 +14,6 @@ ReadPackage( "FreydCategoriesForCAP", "gap/FreydCategory.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/CoFreydCategory.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/CoFreydCategory_as_Opposite_FreydCategory_Opposite.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/AdditiveClosure.gi" ); -ReadPackage( "FreydCategoriesForCAP", "gap/AdditiveClosureDerivedMethods.gi" ); - ReadPackage( "FreydCategoriesForCAP", "gap/CokernelImageClosure.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/AdelmanCategory.gi" ); @@ -39,8 +22,6 @@ ReadPackage( "FreydCategoriesForCAP", "gap/AdelmanCategory.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreyd.gi" ); # =# -ReadPackage( "FreydCategoriesForCAP", "gap/RingsAsAbCats.gi" ); - ReadPackage( "FreydCategoriesForCAP", "gap/GradeFiltration.gi" ); ReadPackage( "FreydCategoriesForCAP", "gap/SerreSubcategoryFunctions.gi" ); diff --git a/FreydCategoriesForCAP/tst/100_LoadPackage.tst b/FreydCategoriesForCAP/tst/100_LoadPackage.tst index c7922c89e5..a1d4a65905 100644 --- a/FreydCategoriesForCAP/tst/100_LoadPackage.tst +++ b/FreydCategoriesForCAP/tst/100_LoadPackage.tst @@ -13,6 +13,8 @@ gap> LoadPackage( "RingsForHomalg", false ); true gap> LoadPackage( "GaussForHomalg", false ); true +gap> LoadPackage( "AdditiveClosuresForCAP", false ); +true gap> LoadPackage( "GeneralizedMorphismsForCAP", false ); true gap> LoadPackage( "FreydCategoriesForCAP", false ); @@ -24,6 +26,8 @@ gap> LoadPackage( "RingsForHomalg" ); true gap> LoadPackage( "GaussForHomalg" ); true +gap> LoadPackage( "AdditiveClosuresForCAP" ); +true gap> LoadPackage( "GeneralizedMorphismsForCAP" ); true gap> LoadPackage( "FreydCategoriesForCAP" ); diff --git a/FreydCategoriesForCAP/tst/Homomorphism_Structure_Freyd_of_Rows_range_cat.tst b/FreydCategoriesForCAP/tst/Homomorphism_Structure_Freyd_of_Rows_range_cat.tst new file mode 100644 index 0000000000..45f7d416b8 --- /dev/null +++ b/FreydCategoriesForCAP/tst/Homomorphism_Structure_Freyd_of_Rows_range_cat.tst @@ -0,0 +1,17 @@ +gap> START_TEST( "Homomorphism_Structure_Freyd_of_Rows_range_cat" ); + +# +gap> LoadPackage( "AdditiveClosuresForCAP", false ); +true +gap> QQ := HomalgFieldOfRationalsInSingular( );; +gap> QQxy := QQ * "x,y";; +gap> EQQxy := KoszulDualRing( QQxy );; +gap> rows := CategoryOfRows( EQQxy );; + +# make sure FreydCategory( rows ) has the same range category of hom structure as rows +# this can only be the case if FreydCategory is able to determine that the distinguished object is projective +gap> IsIdenticalObj( RangeCategoryOfHomomorphismStructure( FreydCategory( rows ) ), RangeCategoryOfHomomorphismStructure( rows ) ); +true + +# +gap> STOP_TEST( "Homomorphism_structure_Freyd_of_Rows_range_cat" ); diff --git a/GroupsAsCategoriesForCAP/PackageInfo.g b/GroupsAsCategoriesForCAP/PackageInfo.g index 60da3cc55b..a36c17b320 100644 --- a/GroupsAsCategoriesForCAP/PackageInfo.g +++ b/GroupsAsCategoriesForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "GroupsAsCategoriesForCAP", Subtitle := "Groups as categories on one object", -Version := "2025.06-02", +Version := "2025.06-03", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", @@ -87,6 +87,7 @@ Dependencies := rec( NeededOtherPackages := [ [ "CAP", ">= 2025.06-05" ], ], SuggestedOtherPackages := [ [ "FinSetsForCAP", ">= 2023.07-03" ], + [ "AdditiveClosuresForCAP", ">= 2025.06-01" ], ], ExternalConditions := [ ], ), diff --git a/LinearAlgebraForCAP/PackageInfo.g b/LinearAlgebraForCAP/PackageInfo.g index bf58a9d7af..6ceb4b492c 100644 --- a/LinearAlgebraForCAP/PackageInfo.g +++ b/LinearAlgebraForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "LinearAlgebraForCAP", Subtitle := "Category of Matrices over a Field for CAP", -Version := "2025.06-02", +Version := "2025.06-03", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", @@ -111,7 +111,7 @@ Dependencies := rec( Extensions := [ rec( - needed := [ [ "FreydCategoriesForCAP", ">= 2024.08-07" ] ], + needed := [ [ "AdditiveClosuresForCAP", ">= 2025.06-01" ] ], filename := "gap/MatrixCategory_as_CategoryOfRows.gi", ), ], diff --git a/LinearAlgebraForCAP/gap/LinearAlgebraForCAP.gi b/LinearAlgebraForCAP/gap/LinearAlgebraForCAP.gi index cf7a33200a..25396b6231 100644 --- a/LinearAlgebraForCAP/gap/LinearAlgebraForCAP.gi +++ b/LinearAlgebraForCAP/gap/LinearAlgebraForCAP.gi @@ -66,13 +66,13 @@ InstallMethod( MatrixCategory, if ValueOption( "no_precompiled_code" ) = true then - if IsPackageMarkedForLoading( "FreydCategoriesForCAP", ">= 2022.10-14" ) then + if IsPackageMarkedForLoading( "AdditiveClosuresForCAP", ">= 2025.06-01" ) then category := MatrixCategory_as_CategoryOfRows( homalg_field ); else - Error( "To get a version of `MatrixCategory` without precompiled code, the package `FreydCategoriesForCAP` is required." ); + Error( "To get a version of `MatrixCategory` without precompiled code, the package `AdditiveClosuresForCAP` is required." ); fi; diff --git a/LinearAlgebraForCAP/gap/MatrixCategory_as_CategoryOfRows.gd b/LinearAlgebraForCAP/gap/MatrixCategory_as_CategoryOfRows.gd index df017e1e2e..6264754bb2 100644 --- a/LinearAlgebraForCAP/gap/MatrixCategory_as_CategoryOfRows.gd +++ b/LinearAlgebraForCAP/gap/MatrixCategory_as_CategoryOfRows.gd @@ -17,7 +17,7 @@ #! The output is the matrix category over $F$, #! constructed internally as a wrapper category of #! the `CategoryOfRows` of $F$. -#! Only available if the package `FreydCategoriesForCAP` is available. +#! Only available if the package `AdditiveClosuresForCAP` is available. #! @Returns a category #! @Arguments F DeclareOperation( "MatrixCategory_as_CategoryOfRows", diff --git a/LinearAlgebraForCAP/tst/200_FreydCategoriesForCAP.tst b/LinearAlgebraForCAP/tst/200_FreydCategoriesForCAP.tst index 1601afec4b..cc43a59a3b 100644 --- a/LinearAlgebraForCAP/tst/200_FreydCategoriesForCAP.tst +++ b/LinearAlgebraForCAP/tst/200_FreydCategoriesForCAP.tst @@ -1,15 +1,15 @@ # SPDX-License-Identifier: GPL-2.0-or-later # LinearAlgebraForCAP: Category of Matrices over a Field for CAP # -# tests without precompiled code need FreydCategoriesForCAP +# tests without precompiled code need AdditiveClosuresForCAP #@if ValueOption( "no_precompiled_code" ) = true gap> PushOptions( rec( OnlyNeeded := true ) ); gap> package_loading_info_level := InfoLevel( InfoPackageLoading );; gap> SetInfoLevel( InfoPackageLoading, PACKAGE_ERROR );; -gap> LoadPackage( "FreydCategoriesForCAP", false ); +gap> LoadPackage( "AdditiveClosuresForCAP", false ); true gap> SetInfoLevel( InfoPackageLoading, PACKAGE_INFO );; -gap> LoadPackage( "FreydCategoriesForCAP" ); +gap> LoadPackage( "AdditiveClosuresForCAP" ); true gap> SetInfoLevel( InfoPackageLoading, package_loading_info_level );; #@fi diff --git a/ModulePresentationsForCAP/PackageInfo.g b/ModulePresentationsForCAP/PackageInfo.g index 5cbb0261f6..d38009cb93 100644 --- a/ModulePresentationsForCAP/PackageInfo.g +++ b/ModulePresentationsForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "ModulePresentationsForCAP", Subtitle := "Category R-pres for CAP", -Version := "2025.06-01", +Version := "2025.06-02", Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ), License := "GPL-2.0-or-later", @@ -112,7 +112,9 @@ Dependencies := rec( Extensions := [ rec( - needed := [ [ "FreydCategoriesForCAP", ">= 2024.01-03" ] ], + needed := [ [ "FreydCategoriesForCAP", ">= 2024.01-03" ], + [ "AdditiveClosuresForCAP", ">= 2025.06-01" ] + ], filename := "gap/ModulePresentations_as_FreydCategory_CategoryOfRowsOrColumns.gi", ), ], diff --git a/README.md b/README.md index 36186ed266..80f50decd7 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,7 @@ Please take a look at our [manual](https://github.com/homalg-project/CAP_project | ---- | ----------- | ------------- | | [CAP](CAP#readme) | Categories, Algorithms, Programming | [![HTML stable documentation][html-CAP-img]][html-CAP-url] [![PDF stable documentation][pdf-CAP-img]][pdf-CAP-url] | | [ActionsForCAP](ActionsForCAP#readme) | Actions and Coactions for CAP | [![HTML stable documentation][html-ActionsForCAP-img]][html-ActionsForCAP-url] [![PDF stable documentation][pdf-ActionsForCAP-img]][pdf-ActionsForCAP-url] | +| [AdditiveClosuresForCAP](AdditiveClosuresForCAP#readme) | Additive closures for pre-abelian categories | [![HTML stable documentation][html-AdditiveClosuresForCAP-img]][html-AdditiveClosuresForCAP-url] [![PDF stable documentation][pdf-AdditiveClosuresForCAP-img]][pdf-AdditiveClosuresForCAP-url] | | [AttributeCategoryForCAP](AttributeCategoryForCAP#readme) | Automatic enhancement with attributes of a CAP category | [![HTML stable documentation][html-AttributeCategoryForCAP-img]][html-AttributeCategoryForCAP-url] [![PDF stable documentation][pdf-AttributeCategoryForCAP-img]][pdf-AttributeCategoryForCAP-url] | | [CartesianCategories](CartesianCategories#readme) | Cartesian and cocartesian categories and various subdoctrines | [![HTML stable documentation][html-CartesianCategories-img]][html-CartesianCategories-url] [![PDF stable documentation][pdf-CartesianCategories-img]][pdf-CartesianCategories-url] | | [CompilerForCAP](CompilerForCAP#readme) | Speed up and verify categorical algorithms | [![HTML stable documentation][html-CompilerForCAP-img]][html-CompilerForCAP-url] [![PDF stable documentation][pdf-CompilerForCAP-img]][pdf-CompilerForCAP-url] | @@ -54,6 +55,13 @@ Please take a look at our [manual](https://github.com/homalg-project/CAP_project [pdf-ActionsForCAP-url]: https://homalg-project.github.io/CAP_project/ActionsForCAP/download_pdf.html +[html-AdditiveClosuresForCAP-img]: https://img.shields.io/badge/🔗%20HTML-stable-blue.svg +[html-AdditiveClosuresForCAP-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/doc/chap0_mj.html + +[pdf-AdditiveClosuresForCAP-img]: https://img.shields.io/badge/🔗%20PDF-stable-blue.svg +[pdf-AdditiveClosuresForCAP-url]: https://homalg-project.github.io/CAP_project/AdditiveClosuresForCAP/download_pdf.html + + [html-AttributeCategoryForCAP-img]: https://img.shields.io/badge/🔗%20HTML-stable-blue.svg [html-AttributeCategoryForCAP-url]: https://homalg-project.github.io/CAP_project/AttributeCategoryForCAP/doc/chap0_mj.html diff --git a/dev/.release b/dev/.release index 518dacf0c7..6dca44c81d 100644 --- a/dev/.release +++ b/dev/.release @@ -14,7 +14,7 @@ sed "s;Date := .*;Date := \"$(date -I)\",;" PackageInfo.g > PackageInfo.g.bak mv PackageInfo.g.bak PackageInfo.g # replace links to packages which are possibly referenced in the documentation, keep this in sync with `Tests.yml.j2` -for package in CAP_project/CAP CAP_project/CompilerForCAP CAP_project/MonoidalCategories CAP_project/CartesianCategories CAP_project/FreydCategoriesForCAP HigherHomologicalAlgebra/ToolsForHigherHomologicalAlgebra homalg_project/homalg homalg_project/Modules CategoricalTowers/ToolsForCategoricalTowers CategoricalTowers/Toposes; do +for package in CAP_project/CAP CAP_project/CompilerForCAP CAP_project/MonoidalCategories CAP_project/CartesianCategories CAP_project/AdditiveClosuresForCAP CAP_project/FreydCategoriesForCAP HigherHomologicalAlgebra/ToolsForHigherHomologicalAlgebra homalg_project/homalg homalg_project/Modules CategoricalTowers/ToolsForCategoricalTowers CategoricalTowers/Toposes; do # adjust links to other manuals # Note that we cannot use sed's `-i` option for in-place editing, as diff --git a/dev/codecov.yml b/dev/codecov.yml index 21cf0ba26a..2a9197bc15 100644 --- a/dev/codecov.yml +++ b/dev/codecov.yml @@ -2,7 +2,7 @@ codecov: disable_default_path_fixes: true require_ci_to_pass: false comment: - after_n_builds: 18 + after_n_builds: 19 flags: CAP: paths: @@ -10,6 +10,9 @@ flags: ActionsForCAP: paths: - "ActionsForCAP/" + AdditiveClosuresForCAP: + paths: + - "AdditiveClosuresForCAP/" AttributeCategoryForCAP: paths: - "AttributeCategoryForCAP/" diff --git a/dev/make_dist.sh b/dev/make_dist.sh index 5df45d7bce..ef1d347e55 100755 --- a/dev/make_dist.sh +++ b/dev/make_dist.sh @@ -12,6 +12,11 @@ echo "Release ActionsForCAP" GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --skip-existing-release --srcdir "$PWD/ActionsForCAP" --webdir "$PWD/gh-pages/ActionsForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" echo "" +# AdditiveClosuresForCAP +echo "Release AdditiveClosuresForCAP" +GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --skip-existing-release --srcdir "$PWD/AdditiveClosuresForCAP" --webdir "$PWD/gh-pages/AdditiveClosuresForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" +echo "" + # AttributeCategoryForCAP echo "Release AttributeCategoryForCAP" GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --skip-existing-release --srcdir "$PWD/AttributeCategoryForCAP" --webdir "$PWD/gh-pages/AttributeCategoryForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" diff --git a/dev/simulate_dist.sh b/dev/simulate_dist.sh index fbed552c79..364a05de87 100755 --- a/dev/simulate_dist.sh +++ b/dev/simulate_dist.sh @@ -12,6 +12,11 @@ echo "Simulate release of ActionsForCAP" GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --srcdir "$PWD/ActionsForCAP" --webdir "$PWD/gh-pages/ActionsForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" --only-tarball echo "" +# AdditiveClosuresForCAP +echo "Simulate release of AdditiveClosuresForCAP" +GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --srcdir "$PWD/AdditiveClosuresForCAP" --webdir "$PWD/gh-pages/AdditiveClosuresForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" --only-tarball +echo "" + # AttributeCategoryForCAP echo "Simulate release of AttributeCategoryForCAP" GAP_PKG_RELEASE_DATE=$(date -I) ./dev/release-gap-package --srcdir "$PWD/AttributeCategoryForCAP" --webdir "$PWD/gh-pages/AttributeCategoryForCAP" --update-script "$PWD/gh-pages/update.g" --release-script "$PWD/dev/.release" --only-tarball diff --git a/dev/upload_codecov.sh b/dev/upload_codecov.sh index da1368c2a9..6927c6727e 100755 --- a/dev/upload_codecov.sh +++ b/dev/upload_codecov.sh @@ -38,6 +38,10 @@ while ! ./codecov -Z -v -s ../ -F ActionsForCAP -t $CODECOV_TOKEN; do echo "Codecov upload failed, retrying in 60s" sleep 60 done +while ! ./codecov -Z -v -s ../ -F AdditiveClosuresForCAP -t $CODECOV_TOKEN; do + echo "Codecov upload failed, retrying in 60s" + sleep 60 +done while ! ./codecov -Z -v -s ../ -F AttributeCategoryForCAP -t $CODECOV_TOKEN; do echo "Codecov upload failed, retrying in 60s" sleep 60 diff --git a/makefile b/makefile index 04224802b7..b0f3a3cb4f 100644 --- a/makefile +++ b/makefile @@ -4,7 +4,7 @@ ci-test: ci-test_all_packages # BEGIN PACKAGE JANITOR ################################ -doc: doc_CAP doc_ActionsForCAP doc_AttributeCategoryForCAP doc_CartesianCategories doc_CompilerForCAP doc_ComplexesAndFilteredObjectsForCAP doc_FreydCategoriesForCAP doc_GeneralizedMorphismsForCAP doc_GradedModulePresentationsForCAP doc_GroupRepresentationsForCAP doc_GroupsAsCategoriesForCAP doc_HomologicalAlgebraForCAP doc_InternalExteriorAlgebraForCAP doc_LinearAlgebraForCAP doc_ModulePresentationsForCAP doc_ModulesOverLocalRingsForCAP doc_MonoidalCategories doc_ToricSheaves +doc: doc_CAP doc_ActionsForCAP doc_AdditiveClosuresForCAP doc_AttributeCategoryForCAP doc_CartesianCategories doc_CompilerForCAP doc_ComplexesAndFilteredObjectsForCAP doc_FreydCategoriesForCAP doc_GeneralizedMorphismsForCAP doc_GradedModulePresentationsForCAP doc_GroupRepresentationsForCAP doc_GroupsAsCategoriesForCAP doc_HomologicalAlgebraForCAP doc_InternalExteriorAlgebraForCAP doc_LinearAlgebraForCAP doc_ModulePresentationsForCAP doc_ModulesOverLocalRingsForCAP doc_MonoidalCategories doc_ToricSheaves doc_CAP: $(MAKE) -C CAP doc @@ -12,6 +12,9 @@ doc_CAP: doc_ActionsForCAP: $(MAKE) -C ActionsForCAP doc +doc_AdditiveClosuresForCAP: + $(MAKE) -C AdditiveClosuresForCAP doc + doc_AttributeCategoryForCAP: $(MAKE) -C AttributeCategoryForCAP doc @@ -61,7 +64,7 @@ doc_ToricSheaves: $(MAKE) -C ToricSheaves doc ################################ -test: doc test_CAP test_ActionsForCAP test_AttributeCategoryForCAP test_CartesianCategories test_CompilerForCAP test_ComplexesAndFilteredObjectsForCAP test_FreydCategoriesForCAP test_GeneralizedMorphismsForCAP test_GradedModulePresentationsForCAP test_GroupRepresentationsForCAP test_GroupsAsCategoriesForCAP test_HomologicalAlgebraForCAP test_InternalExteriorAlgebraForCAP test_LinearAlgebraForCAP test_ModulePresentationsForCAP test_ModulesOverLocalRingsForCAP test_MonoidalCategories test_ToricSheaves +test: doc test_CAP test_ActionsForCAP test_AdditiveClosuresForCAP test_AttributeCategoryForCAP test_CartesianCategories test_CompilerForCAP test_ComplexesAndFilteredObjectsForCAP test_FreydCategoriesForCAP test_GeneralizedMorphismsForCAP test_GradedModulePresentationsForCAP test_GroupRepresentationsForCAP test_GroupsAsCategoriesForCAP test_HomologicalAlgebraForCAP test_InternalExteriorAlgebraForCAP test_LinearAlgebraForCAP test_ModulePresentationsForCAP test_ModulesOverLocalRingsForCAP test_MonoidalCategories test_ToricSheaves test_CAP: $(MAKE) -C CAP test @@ -69,6 +72,9 @@ test_CAP: test_ActionsForCAP: $(MAKE) -C ActionsForCAP test +test_AdditiveClosuresForCAP: + $(MAKE) -C AdditiveClosuresForCAP test + test_AttributeCategoryForCAP: $(MAKE) -C AttributeCategoryForCAP test @@ -118,7 +124,7 @@ test_ToricSheaves: $(MAKE) -C ToricSheaves test ################################ -ci-test_all_packages: ci-test_CAP ci-test_ActionsForCAP ci-test_AttributeCategoryForCAP ci-test_CartesianCategories ci-test_CompilerForCAP ci-test_ComplexesAndFilteredObjectsForCAP ci-test_FreydCategoriesForCAP ci-test_GeneralizedMorphismsForCAP ci-test_GradedModulePresentationsForCAP ci-test_GroupRepresentationsForCAP ci-test_GroupsAsCategoriesForCAP ci-test_HomologicalAlgebraForCAP ci-test_InternalExteriorAlgebraForCAP ci-test_LinearAlgebraForCAP ci-test_ModulePresentationsForCAP ci-test_ModulesOverLocalRingsForCAP ci-test_MonoidalCategories ci-test_ToricSheaves +ci-test_all_packages: ci-test_CAP ci-test_ActionsForCAP ci-test_AdditiveClosuresForCAP ci-test_AttributeCategoryForCAP ci-test_CartesianCategories ci-test_CompilerForCAP ci-test_ComplexesAndFilteredObjectsForCAP ci-test_FreydCategoriesForCAP ci-test_GeneralizedMorphismsForCAP ci-test_GradedModulePresentationsForCAP ci-test_GroupRepresentationsForCAP ci-test_GroupsAsCategoriesForCAP ci-test_HomologicalAlgebraForCAP ci-test_InternalExteriorAlgebraForCAP ci-test_LinearAlgebraForCAP ci-test_ModulePresentationsForCAP ci-test_ModulesOverLocalRingsForCAP ci-test_MonoidalCategories ci-test_ToricSheaves ci-test_CAP: $(MAKE) -C CAP ci-test @@ -126,6 +132,9 @@ ci-test_CAP: ci-test_ActionsForCAP: $(MAKE) -C ActionsForCAP ci-test +ci-test_AdditiveClosuresForCAP: + $(MAKE) -C AdditiveClosuresForCAP ci-test + ci-test_AttributeCategoryForCAP: $(MAKE) -C AttributeCategoryForCAP ci-test