I want u to turn this into a beautiful manim code explanation with visualisations and everything and good transitions and all just like a 3blue1brown video

# src

## Givens

- circular flat grid
- one-sided ****portal
- $s_1$ is barrier
- $s_2$ something can pass through

---

## Questions (Solved)

- how does $s_1$ link to $s_2$, **symmetry**
- what’s the constant in $p(x)$ that affects the outcome $y$
    - let $p$ be an array, $p_i$ affects the outcome of y since current index is what affects outcome (injectivity)
- How can I use the fact that the portal is 1-sided and needs to become 2 sided?
    
    > **Symmetry**
    firsly, we must start by defining our constants, let p be the parent function, in which we have s1 and s2, we then represent these 2 states by a dp array, if we want to represent this as something that can take in input and process output in 2 ways, and not have some type of LIFO, FIFO or a queue. We set the value of s1[i] equal to s2[i] we can then find instances where s1[i] ≠ s2[i], we can figure out the complexity of the difference my checking the difference between the values using something like abs(s1[i] - s2[i]), proof of bijectivity then handles the rest since everything gets mapped. 
    then we must follow up by identifying symmetrical patterns within the maze, such as rotational or reflective symmetries. Let’s denote these symmetrical regions by r1 and r2. We then represent these regions using a simplified DP array where we consolidate identical sections into a single representation. By recognizing that regions r1 and r2 are equivalent due to symmetry, we can merge them to reduce redundancy. When updating the DP array, we only need to account for unique states and transitions, adjusting the recurrence relation to reflect this simplified structure. This process simplifies the maze by removing redundant paths and updating transitions, ensuring that the maze-solving process remains efficient and manageable.
    > 
    

---

## Observations

- I can use portals as funtions.
    - ~~maybe surjetive/bijective function?~~ defo bijective
- we cannot see other than what’s currently being iterated over, but we can keep track over what was previously visited
- an entrance can be used as an exit too
- recognize the need to record when the portal has been used to enable reverse transitions
- symmetry links to injectivity → (proof of injectivity)
- symmetry in the maze allows for regions to be treated as equivalent
- we can merge symmetrical regions (e.g., rotational or reflective symmetries) to consolidate them into a single representation in the DP array
- the recurrence relation must be adjusted to account for unique states, rather than repeating identical regions multiple times
- symmetry simplifies the transition map, as symmetrical paths lead to the same outcome, allowing for deletion of redundant paths

---

## Proofs

> **Proof of surjectivity**
> 
> 
> If i have 2 states, $s_1$ and $s_2$, then certainly this bijectivity should hold for both states:
> 
> for $s_n$ in $x$ there exists a value such that it maps for the other state, therefore $p : x→y$   must be injective
> 

> **Proof of reccurence relation**
If we have two states, $s_1$ and $s_2$, we can describe the recurrence relation based on the transitions between these states. For each state $s_n$, the recurrence relation defines the number of ways to reach that state based on previous states. Therefore, the recurrence relation can be written as:
> 
> 
> dp[i] = 0, for j in possible_transitions(i): dp[i] += dp[j]
> This makes sure that the number of ways to reach a state depends on prior reachable states, the recurrence relation must satisfy that each state's value is derived from legitimate transitions, thereby constructing a valid and efficient mapping of state sequences
> 

> **Proof of symmetry deletion**
If a maze exhibits symmetry, such as rotational or reflective symmetry, we can represent symmetric regions as equivalent. Let $r_1$ and $r_2$ be symmetrical regions. Due to symmetry, there exists a mapping where $r_1 \equiv r_2$ 
This allows us to consolidate the symmetric regions into a single representation, by deleting one of the redundant regions and merging their states, we ensure that no unique information is lost. The simplification holds as long as the behavior and outcome within the symmetric regions are identical. Hence, the deletion maintains the structural integrity of the maze-solving process.
> 

> **Proof of path redundancy elimination**
Given a set of paths $p_1, p_2, \dots, p_n$ , if symmetry causes two or more paths to lead to the same outcome, we can eliminate redundant paths. For example, if $p_1$ and $p_2$ are symmetric and lead to state $s$, then: $p_1 \rightarrow s \quad \text{and} \quad p_2 \rightarrow s$
Since the outcome is identical, one of these paths can be safely removed without affecting the maze traversal. This ensures the recurrence relation only tracks unique transitions and optimizes the computational complexity by reducing unnecessary paths.
>