reorganizacion

SEGUNDO/MD/Apuntes Sage.md

@@ -1,166 +0,0 @@
-# Práctica 1
-<hr>
-
-### Métodos principales: 
-```python
-# Sea G = Graph()/DiGraph()
-G.plot(figsize=int, layout='circular/tree', vertex_size=int, vertex_colors=dict, edge_colors=dict)
-G.add_vertex(v)/vertices()/delete_vertex(v) # vertices
-G.add_edge((src,dst))/edges()/delete_edge((src,dst)) # aristas
-G.degree(vertice)/in_degree(vertice)/out_degree(vertice) # valencia/grado
-G.neighbors(vertice) # vecinos/adyacentes
-G.size() # nº aristas
-G.order() # nº vertices
-G.complement() # complementario
-G.is_isomorphic(G2) # es isomorfo a G2? -> boolean
-G.adjacency_matrix() # matriz adyacencia
-G.subgraph(vertices) # subgrafo inducido
-
-# Grafo manualmente
-G1 = Graph({0:[1,2,3],2:[1,3,4],3:[4]})
-G1 = Graph(M) # sea M su matriz de adyacencia
-```
-
-### Operaciones con grafos: 
-```python
-# Sean G1 y G2 grafos
-G1 + G2 # G1 U G2
-G1.join(G2) # G1 + G2
-```
-
-# Práctica 2
-<hr>
-
-### Digrafos para juegos (usando el kernel)
-1. Digrafo con tantos vértices como posibles posiciones del juego.
-2. Las posiciones ganadoras se corresponderán con vértices $\delta({v})=0$
-
-Para obtener el kernel:
-```python
-# Sea DG = DiGraph()
-kernel(DG) # kernel() definido en Practica 2
-```
-
-### Nº de independencia y Nº de clique
-- **Nº independencia:** tamaño del mayor conjunto independiente de vértices
-```python
-S = G.independent_set() # mayor conjunto independiente
-len(S) # numero de independencia
-```
-- **Nº de clique:** $n~/~C_n$
-```python
-G.clique_number() # numero de clique
-G.cliques_maximal() # cliques maximales (no contenidos en otros cliques)
-G.cliques_maximum() # cliques máximos (mayor cardinal)
-```
-
-# Práctica 3
-<hr>
-
-### Distancias y matriz de adyacencia
-Sea $G=~Graph()$
-Sea $M$ la matriz de adyacencia de $G$
-
-Los elementos de $M^n$ indican que hay $m_{ij}$ caminos de longitud $n$ entre $v_i$ y $v_j$
-### Distancias y elementos métricos
-- **Distancia:** Longitud del camino más corto entre dos vértices.
-```python
-# Sea G = Graph()
-G.distance(v1,v2)
-```
-- **Excentricidad:** Distancia de un vértice a su vecino más alejado.
-```python
-# Sea G = Graph()
-G.eccentricity(v) # sin parametros -> lista de excentricidades
-```
-    - *Radio:* Menor excentricidad
-    - *Diámetro:* Mayor excentricidad
-- **Centro:** Conjunto de vértices cuya excentricidad es igual al radio.
-```python
-# Sea G = Graph()
-G.center()
-```
-- **Periferia:** Conjunto de vértices de mayor excentricidad.
-```python
-# Sea G = Graph()
-G.periphery()
-```
-
-### Conectividad
-```python
-# Sea G = Graph()
-G.is_connected()/is_strongly_connected() # ver si es conexo/fuertemente conexo
-G.connected_components()/strongly_connected_components() # lista de componentes conexas / fuertemente conexas
-G.connected_component_containing_vertex(v) # a donde esta conectado v
-```
-
-### k-Conexión
-```python
-# Sea G = Graph()
-G.vertex_connectivity() # conectividad por vértices
-G.edge_connectivity() # conectividad por aristas
-G.blocks_and_cut_vertices() # [bloques,vs_corte]
-```
-
-# Práctica 4
-<hr>
-
-### Árboles
-```python
-# Sea G = Graph()
-G.is_tree() # ver si es arbol -> boolean
-G.is_forest() # ver si es bosque -> boolean
-```
-
-### DFS, BFS, Kruskal, Dijkstra, digrafo_laberinto
-Las funciones más importantes:
-- `arbol_dfs(DG,inicial)` -> Árbol en profundidad (estudiar vertices de corte)
-- `arbol_bfs(DG, v)` -> Árbol en anchura (camino mas corto desde v a cualquiera. Si G -> G.to_directed() = DG. 
-- `digrafo_laberinto(filas,columnas,obstver,obsthor)` -> Digrafo que resuelve el laberinto
-    - obstver: lista de columnas que tienen obstaculo a la derecha
-    - obsthor: lista de columnas que tienen obstaculo debajo
-- `Kruskal(G_ponderado)` -> Arbol de peso minimo
-- `Dijkstra(G, inicial)` -> Caminos mas cortos desde el inicial
-    
-Para resolver un laberinto se usa `digrafo_laberinto` y luego `arbol_bfs`.
-
-# Práctica 5
-<hr>
-
-### Multigrafo
-```python
-# Sea G = Graph()
-G.allow_multiple_edges() # indicar que tendra aristas multiples
-```
-
-### Grafos Eulerianos
-```python
-# Sea G = Graph()
-G.is_eulerian() # ver si es euleriano -> boolean
-G.is_eulerian(path=True) # si False no es semieuleriano. Si lo es, devuelve v_i y v_f del recorrido.
-G.eulerian_circuit(path=True) # circuito semieuleriano en caso de que lo sea
-```
-#### Si no es E ni Semi E, ¿numero de saltos?
-Se convierte en multigrafo y se añaden aristas postizas (bucle `for` en Practica 5)
-
-### Grafos Hamiltonianos
-```python
-# Sea G = Graph()
-G.is_hamiltonian() # ver si es hamiltoniano -> boolean
-G.hamiltonian_cycle() # ciclo hamiltoniano si G es H
-G.hamiltonian_path() # camino hamiltoniano si G es Semi H
-```
-
-**DIRAC:** Un grafo de $n$ vértices ($n>3$) es hamiltoniano si cada vértice tiene valencia mayor o igual a $n/2$.
-**ORE:** Un grafo de $n$ vértices ($n>3$) es hamiltoniano si la suma de valencias de cada pareja de vértices no adyacentes es mayor o igual que $n$.
-### Coloracion vertices
-```python
-voraz(G,p=[]) # definido en Práctica 5
-```
-Si un grafo $G$ contiene un clique de $m$, $\chi(G)\geq m$ por tanto $clique(G)\leq\chi(G)$.
-
-### Coloracion aristas
-```python
-# Sea G = Graph
-G.chromatic_index() # numero cromatico por aristas
-```