Use markdown links

See <scientific-python/scientific-python-hugo-theme#568>.

Author: alphapapa

content/about/_index.md

@@ -22,7 +22,7 @@ Community members must adhere to our
 ## People
 
 For more information, see our
-[governance and decision making process]({{< relref "/about/governance" >}}).
+[governance and decision making process](/about/governance).
 
 ### Blog Reviewers
 

content/about/review.md

@@ -20,9 +20,9 @@ We distinguish contributors with 3 roles:
 
 Contributors are promoted from one status to the other at the discretion of the
 editorial board. For more information, see our
-[governance and decision making process]({{< relref "/about/governance" >}}).
+[governance and decision making process](/about/governance).
 
-The content must follow our [scope]({{< relref "/about/submit#scope" >}}).
+The content must follow our [scope](/about/submit#scope).
 As we thrive for quality posts, some submissions will not meet the bar.
 Please try to give clear feedback on how authors could revise their
 submission. It should also be clear if a submission would not be accepted.

content/posts/networkx/aTSP/a-closer-look-at-held-karp/index.md

@@ -22,7 +22,7 @@ After talking with my GSoC mentors about what we all believe to be the most diff
   An example of this would be the ellipsoid algorithm versus the simplex algorithm.
   While the simplex algorithm is exponential, in practice it is almost always faster than the ellipsoid algorithm.
 - Our interest in the ellipsoid algorithm was not based on performance, but rather the ability for the ellipsoid algorithm to be able to handle a linear program with an exponential number of constraints.
-  This was done with a separation oracle, see my post [here]({{< relref "held-karp-separation-oracle" >}}) for more information about the oracle.
+  This was done with a separation oracle, see my post [here](held-karp-separation-oracle) for more information about the oracle.
 - Implementing a robust ellipsoid algorithm solver (something notable missing from the scientific python ecosystem) was a GSoC project onto itself and beyond the scope of this project for NetworkX.
 
 Thus, alternative methods for solving the Held-Karp relaxation needed to be investigated.

content/posts/networkx/aTSP/entropy-distribution/index.md

@@ -24,7 +24,7 @@ Recall that the algorithm for creating the distribution is given in the Asadpour
 >    - Set $\gamma \leftarrow \gamma'$.
 > 3. Output $\tilde{\gamma} := \gamma$.
 
-Now, the procedure that I laid out in my last blog titled [Entropy Distribution Setup]({{< relref "entropy-distribution-setup" >}}) worked well for the while loop portion.
+Now, the procedure that I laid out in my last blog titled [Entropy Distribution Setup](entropy-distribution-setup) worked well for the while loop portion.
 All of my difficulties with the NetworkX API happened in the `q` inner function.
 
 After I programmed the function, I of course needed to run it and at first I was just printing the `gamma` dict out so that I could see what the values for each edge were.

content/posts/networkx/aTSP/finalizing-held-karp/index.md

@@ -16,7 +16,7 @@ resources:
 ---
 
 This _should_ be my final post about the Held-Karp relaxation!
-Since my last post titled [Implementing The Held Karp Relaxation]({{< relref "implementing-the-held-karp-relaxation" >}}), I have been testing both the ascent method as well as the branch and bound method.
+Since my last post titled [Implementing The Held Karp Relaxation](implementing-the-held-karp-relaxation), I have been testing both the ascent method as well as the branch and bound method.
 
 My first test was to use a truly asymmetric graph rather than a directed graph where the cost in each direction happened to be the same.
 In order to create such a test, I needed to know the solution to any such proposed graphs.

content/posts/networkx/aTSP/finding-all-minimum-arborescences/index.md

@@ -17,7 +17,7 @@ resources:
 
 There is only one thing that I need to figure out before the first coding period for GSoC starts on Monday: how to find _all_ of the minimum arborescences of a graph.
 This is the set $K(\pi)$ in the Held and Karp paper from 1970 which can be refined down to $K(\pi, d)$ or $K\_{X, Y}(\pi)$ as needed.
-For more information as to why I need to do this, please see my last post [here]({{< relref "a-closer-look-at-held-karp" >}}).
+For more information as to why I need to do this, please see my last post [here](a-closer-look-at-held-karp).
 
 This is a place where my contributions to NetworkX to implement the Asadpour algorithm [1] for the directed traveling salesman problem will be useful to the rest of the NetworkX community (I hope).
 The research paper that I am going to template this off of is [this](https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en&format=pdf) 2005 paper by Sörensen and Janssens titled _An Algorithm to Generate all Spanning Trees of a Graph in Order of Increasing Cost_ [4].

content/posts/networkx/aTSP/implementing-the-held-karp-relaxation/index.md

@@ -16,7 +16,7 @@ resources:
 ---
 
 I have now completed my implementation of the ascent and the branch and bound method detailed in the 1970 paper _The Traveling-Salesman Problem and Minimum Spanning Trees_ by Micheal Held and Richard M. Karp.
-In my last post, titled [Understanding the Ascent Method]({{< relref "understanding-the-ascent-method" >}}), I completed the first iteration of the ascent method and found an important bug in the `find_epsilon()` method and found a more efficient way to determine substitutes in the graph.
+In my last post, titled [Understanding the Ascent Method](understanding-the-ascent-method), I completed the first iteration of the ascent method and found an important bug in the `find_epsilon()` method and found a more efficient way to determine substitutes in the graph.
 However the solution being given was still not the optimal solution.
 
 After discussing my options with my GSoC mentors, I decided to move onto the branch and bound method anyways with the hope that because the method is more human-computable and an example was given in the paper by Held and Karp that I would be able to find the remaining flaws.

content/posts/networkx/aTSP/implementing-the-iterators/index.md

@@ -84,7 +84,7 @@ The code for the spanning tree iterator can be found [here](https://github.com/m
 ## Arborescence Iterator
 
 The arborescence iterator is what I actually need for my GSoC project, and as expected was more complicated to implement.
-In my original post titled [Finding All Minimum Arborescences]({{< relref "finding-all-minimum-arborescences" >}}), I discussed cases that Edmond's algorithm [1] would need to handle and proposed a change to the `desired_edge` method.
+In my original post titled [Finding All Minimum Arborescences](finding-all-minimum-arborescences), I discussed cases that Edmond's algorithm [1] would need to handle and proposed a change to the `desired_edge` method.
 
 These changes where easy to make, but were not the extent of the changes that needed to be made as I originally thought.
 The original graph from Edmonds' 1967 paper is below

content/posts/networkx/aTSP/looking-at-the-big-picture/index.md

@@ -48,7 +48,7 @@ Recall that from the Asadpour paper the overview of the algorithm is
 > ---
 
 We are now firmly in the steps 3 and 4 area.
-Going all the way back to my post on 24 May 2021 titled [Networkx Function stubs]({{< relref "networkx-function-stubs" >}}) the only function left is `asadpour_tsp`, the main function which needs to accomplish this entire algorithm.
+Going all the way back to my post on 24 May 2021 titled [Networkx Function stubs](networkx-function-stubs) the only function left is `asadpour_tsp`, the main function which needs to accomplish this entire algorithm.
 But before we get to creating pseudo code for it there is still step 4 which needs a thorough examination.
 
 ## Circulation and Shortcutting
@@ -95,7 +95,7 @@ def asadpour_tsp
 ```
 
 This is exactly what we'd expect, take a complete graph $G$ satisfying the triangle inequality and return the edges in the approximate solution to the asymmetric traveling salesman problem.
-Recall from my post [Networkx Function Stubs]({{< relref "networkx-function-stubs" >}}) what the primary traveling salesman function, `traveling_salesman_problem` will ensure that we are given a complete graph that follows the triangle inequality by using all-pairs shortest path calculations and will handle if we are expected to return a true cycle or only a path.
+Recall from my post [Networkx Function Stubs](networkx-function-stubs) what the primary traveling salesman function, `traveling_salesman_problem` will ensure that we are given a complete graph that follows the triangle inequality by using all-pairs shortest path calculations and will handle if we are expected to return a true cycle or only a path.
 
 The first step in the Asadpour algorithm is the Held Karp relaxation.
 I am planning on editing the flow of the algorithm here a bit.

content/posts/networkx/aTSP/my-summer-of-code-2021/index.md

@@ -81,9 +81,9 @@ This class I'm sure will be useful to the other users of NetworkX and provided a
 
 **Blog Posts about `SpanningTreeIterator`**
 
-5 Jun 2021 - [Finding All Minimum Arborescences]({{< relref "finding-all-minimum-arborescences" >}})
+5 Jun 2021 - [Finding All Minimum Arborescences](../finding-all-minimum-arborescences)
 
-10 Jun 2021 - [Implementing The Iterators]({{< relref "implementing-the-iterators" >}})
+10 Jun 2021 - [Implementing The Iterators](../implementing-the-iterators)
 
 **Commits about `SpanningTreeIterator`**
 
@@ -124,9 +124,9 @@ This was used as part of the branch and bound method, but is no longer a part of
 
 **Blog Posts about `ArborescenceIterator`**
 
-5 Jun 2021 - [Finding All Minimum Arborescences]({{< relref "finding-all-minimum-arborescences" >}})
+5 Jun 2021 - [Finding All Minimum Arborescences](finding-all-minimum-arborescences)
 
-10 Jun 2021 - [Implementing The Iterators]({{< relref "implementing-the-iterators" >}})
+10 Jun 2021 - [Implementing The Iterators](implementing-the-iterators)
 
 **Commits about `ArborescenceIterator`**
 
@@ -190,21 +190,21 @@ All of this is detailed in the (many) blog posts I wrote on this topic, which ar
 
 My first two posts were about the `scipy` solution and the ellipsoid algorithm.
 
-11 Apr 2021 - [Held Karp Relaxation]({{< relref "held-karp-relaxation" >}})
+11 Apr 2021 - [Held Karp Relaxation](../held-karp-relaxation)
 
-8 May 2021 - [Held Karp Separation Oracle]({{< relref "held-karp-separation-oracle" >}})
+8 May 2021 - [Held Karp Separation Oracle](../held-karp-separation-oracle)
 
 This next post discusses the merits of each algorithm presenting in the original Held and Karp paper [3].
 
-3 Jun 2021 - [A Closer Look At Held Karp]({{< relref "a-closer-look-at-held-karp" >}})
+3 Jun 2021 - [A Closer Look At Held Karp](../a-closer-look-at-held-karp)
 
 And finally, the last three Held Karp related posts are about the debugging of the algorithms I did implement.
 
-22 Jun 2021 - [Understanding The Ascent Method]({{< relref "understanding-the-ascent-method" >}})
+22 Jun 2021 - [Understanding The Ascent Method](../understanding-the-ascent-method)
 
-28 Jun 2021 - [Implementing The Held Karp Relaxation]({{< relref "implementing-the-held-karp-relaxation" >}})
+28 Jun 2021 - [Implementing The Held Karp Relaxation](../implementing-the-held-karp-relaxation)
 
-7 Jul 2021 - [Finalizing Held Karp]({{< relref "finalizing-held-karp" >}})
+7 Jul 2021 - [Finalizing Held Karp](../finalizing-held-karp)
 
 **Commits about the Held Karp relaxation**
 
@@ -278,9 +278,9 @@ Multiplying my original value of $q_e(\gamma)$ by $\exp(\gamma_e)$ proved to be
 
 **Blog posts about `spanning_tree_distribution`**
 
-13 Jul 2021 - [Entropy Distribution Setup]({{< relref "entropy-distribution-setup" >}})
+13 Jul 2021 - [Entropy Distribution Setup](../entropy-distribution-setup)
 
-20 Jul 2021 - [The Entropy Distribution]({{< relref "entropy-distribution" >}})
+20 Jul 2021 - [The Entropy Distribution](../entropy-distribution)
 
 **Commits about `spanning_tree_distribution`**
 
@@ -336,9 +336,9 @@ Unfortunately, the test would still fail 1% of the time until I added the `@py_r
 
 **Blog posts about `sample_spanning_tree`**
 
-21 Jul 2021 - [Preliminaries For Sampling A Spanning Tree]({{< relref "preliminaries-for-sampling-a-spanning-tree" >}})
+21 Jul 2021 - [Preliminaries For Sampling A Spanning Tree](../preliminaries-for-sampling-a-spanning-tree)
 
-28 Jul 2021 - [Sampling A Spanning Tree]({{< relref "sampling-a-spanning-tree" >}})
+28 Jul 2021 - [Sampling A Spanning Tree](../sampling-a-spanning-tree)
 
 **Commits about `sample_spanning_tree`**
 
@@ -373,9 +373,9 @@ A brief overview of the whole algorithm is given below:
 
 **Blog posts about `asadpour_atsp`**
 
-29 Jul 2021 - [Looking At The Big Picture]({{< relref "looking-at-the-big-picture" >}})
+29 Jul 2021 - [Looking At The Big Picture](../looking-at-the-big-picture)
 
-10 Aug 2021 - [Completing The Asadpour Algorithm]({{< relref "completing-the-asadpour-algorithm" >}})
+10 Aug 2021 - [Completing The Asadpour Algorithm](../completing-the-asadpour-algorithm)
 
 **Commits about `asadpour_atsp`**
 

content/posts/networkx/aTSP/networkx-function-stubs/index.md

@@ -120,7 +120,7 @@ def asadpour_tsp(G, weight="weight"):
     pass
 ```
 
-Following my GSoC proposal, the next function is `held_karp`, which will solve the Held-Karp relaxation on the complete digraph using the ellipsoid method (See my last two posts [here]({{< relref "held-karp-relaxation" >}}) and [here]({{< relref "held-karp-separation-oracle" >}}) for my thoughts on why and how to accomplish this).
+Following my GSoC proposal, the next function is `held_karp`, which will solve the Held-Karp relaxation on the complete digraph using the ellipsoid method (See my last two posts [here](held-karp-relaxation) and [here](held-karp-separation-oracle) for my thoughts on why and how to accomplish this).
 Solving the Held-Karp relaxation is the first step in the algorithm.
 
 Recall that the Held-Karp relaxation is defined as the following linear program:

content/posts/networkx/aTSP/sampling-a-spanning-tree/index.md

@@ -38,7 +38,7 @@ First recall how edge contraction, or in this case node contraction, works.
 Two nodes are merged into one which is connected by the same edges which connected the original two nodes.
 Edges between those two nodes become self loops, but in this case I prevented the creation of self loops as directed by Kulkarni.
 If a node which is not contracted has edges to both of the contracted nodes, we insert a parallel edge between them.
-I struggled with NetworkX's API about the graph classes in a past post titled [The Entropy Distribution]({{< relref "entropy-distribution" >}}).
+I struggled with NetworkX's API about the graph classes in a past post titled [The Entropy Distribution](entropy-distribution).
 
 For NetworkX's implementation, we would call `nx.contracted_nodes(G, u, v)` and `u` and `v` would always be merged into `u`, so `v` is the node which is no longer in the graph.
 

content/posts/networkx/outreachy2023/contribution-phase/index.md

@@ -42,4 +42,4 @@ If this is your first time contributing to an open-source project you may feel o
 
 I hope this information helps you to start your Open-Source journey! The NetworkX team is waiting for your great contributions!
 
-If you are interested in my experience during the internship you can find the second part of this blog [here]({{< relref "internship" >}}).
+If you are interested in my experience during the internship you can find the second part of this blog [here](../internship).

content/posts/networkx/outreachy2023/internship/index.md

@@ -10,7 +10,7 @@ displayInList: true
 author: ["Paula Pérez Bianchi"]
 ---
 
-This is the second part of a blog series where I talk about my experience during my Outreachy internship at NetworkX. If you haven’t read the first part you can find it [here]({{< relref "contribution-phase" >}}).
+This is the second part of a blog series where I talk about my experience during my Outreachy internship at NetworkX. If you haven’t read the first part you can find it [here](../contribution-phase).
 
 As you advance through the contribution phase you may wonder how your internship is gonna be in case you get selected. Here is my experience as a **NetworkX** intern and some tips that could help you through the internship.
 

content/posts/networkx/vf2pp/ISO-feasibility-candidates/index.md

@@ -11,7 +11,7 @@ author: ["Konstantinos Petridis"]
 
 ---
 
-The previous post can be found [here]({{< relref "node-ordering-Ti-updating" >}}), be sure to check it out so you
+The previous post can be found [here](../node-ordering-Ti-updating), be sure to check it out so you
 can
 follow the process step by step. Since then, another two very significant features of the algorithm have been
 implemented and tested: **node pair candidate selection** and **feasibility checks**.

content/posts/networkx/vf2pp/graph-iso-vf2pp/index.md

@@ -11,7 +11,7 @@ author: ["Konstantinos Petridis"]
 
 ---
 
-The last and final post discussing the **VF2++ helpers** can be found [here]({{< relref "ISO-feasibility-candidates" >}}).
+The last and final post discussing the **VF2++ helpers** can be found [here](../ISO-feasibility-candidates).
 Now that we've figured out how to solve all the sub-problems that **VF2++** consists of, we are ready to combine our
 implemented functionalities to create the final solver for the **Graph Isomorphism** problem.
 

content/posts/networkx/vf2pp/node-ordering-Ti-updating/index.md

@@ -11,7 +11,7 @@ author: ["Konstantinos Petridis"]
 
 ---
 
-This post includes all the major updates since the [last post]({{< relref "GSoC-2022" >}}) about VF2++. Each section
+This post includes all the major updates since the [last post](../gsoc-2022) about VF2++. Each section
 is dedicated to a different sub-problem and presents the progress on it so far. General progress, milestones and related
 issues can be [found here](https://github.com/kpetridis24/networkx/milestone/1).