File: Mathlib/Combinatorics/SimpleGraph/Dart.lean

full_name: SimpleGraph.Dart.adj
code: /-- A `Dart` is an oriented edge, implemented as an ordered pair of adjacent vertices.
This terminology comes from combinatorial maps, and they are also known as "half-edges"
or "bonds." -/
structure Dart extends V × V where
  adj : G.Adj fst snd
  deriving DecidableEq
goal: G.Adj self.toProd.1 self.toProd.2

full_name: SimpleGraph.Dart
code: /-- A `Dart` is an oriented edge, implemented as an ordered pair of adjacent vertices.
This terminology comes from combinatorial maps, and they are also known as "half-edges"
or "bonds." -/
structure Dart extends V × V where
  adj : G.Adj fst snd
  deriving DecidableEq
goal: Type u_1

full_name: SimpleGraph.Dart.ext_iff
code: theorem Dart.ext_iff (d₁ d₂ : G.Dart) : d₁ = d₂ ↔ d₁.toProd = d₂.toProd 
goal: d₁ = d₂ ↔ d₁.toProd = d₂.toProd

full_name: SimpleGraph.Dart.ext
code: @[ext]
theorem Dart.ext (d₁ d₂ : G.Dart) (h : d₁.toProd = d₂.toProd) : d₁ = d₂ 
goal: d₁ = d₂

full_name: SimpleGraph.Dart.toProd_injective
code: theorem Dart.toProd_injective : Function.Injective (Dart.toProd : G.Dart → V × V) 
goal: Function.Injective SimpleGraph.Dart.toProd

full_name: SimpleGraph.Dart.fintype
code: instance Dart.fintype [Fintype V] [DecidableRel G.Adj] : Fintype G.Dart 
goal: Fintype G.Dart

full_name: SimpleGraph.Dart.edge
code: /-- The edge associated to the dart. -/
def Dart.edge (d : G.Dart) : Sym2 V 
goal: Sym2 V

full_name: SimpleGraph.Dart.edge_mk
code: @[simp]
theorem Dart.edge_mk {p : V × V} (h : G.Adj p.1 p.2) : (Dart.mk p h).edge = Sym2.mk p 
goal: { toProd := p, adj := h }.edge = Sym2.mk p

full_name: SimpleGraph.Dart.edge_mem
code: @[simp]
theorem Dart.edge_mem (d : G.Dart) : d.edge ∈ G.edgeSet 
goal: d.edge ∈ G.edgeSet

full_name: SimpleGraph.Dart.symm_toProd
code: /-- The dart with reversed orientation from a given dart. -/
@[simps]
def Dart.symm (d : G.Dart) : G.Dart 
goal: d.symm.toProd = d.swap

full_name: SimpleGraph.Dart.symm
code: /-- The dart with reversed orientation from a given dart. -/
@[simps]
def Dart.symm (d : G.Dart) : G.Dart 
goal: G.Dart

full_name: SimpleGraph.Dart.symm_mk
code: @[simp]
theorem Dart.symm_mk {p : V × V} (h : G.Adj p.1 p.2) : (Dart.mk p h).symm = Dart.mk p.swap h.symm 
goal: { toProd := p, adj := h }.symm = { toProd := p.swap, adj := ⋯ }

full_name: SimpleGraph.Dart.edge_symm
code: @[simp]
theorem Dart.edge_symm (d : G.Dart) : d.symm.edge = d.edge 
goal: d.symm.edge = d.edge

full_name: SimpleGraph.Dart.edge_comp_symm
code: @[simp]
theorem Dart.edge_comp_symm : Dart.edge ∘ Dart.symm = (Dart.edge : G.Dart → Sym2 V) 
goal: SimpleGraph.Dart.edge ∘ SimpleGraph.Dart.symm = SimpleGraph.Dart.edge

full_name: SimpleGraph.Dart.symm_symm
code: @[simp]
theorem Dart.symm_symm (d : G.Dart) : d.symm.symm = d 
goal: d.symm.symm = d

full_name: SimpleGraph.Dart.symm_involutive
code: @[simp]
theorem Dart.symm_involutive : Function.Involutive (Dart.symm : G.Dart → G.Dart) 
goal: Function.Involutive SimpleGraph.Dart.symm

full_name: SimpleGraph.Dart.symm_ne
code: theorem Dart.symm_ne (d : G.Dart) : d.symm ≠ d 
goal: d.symm ≠ d

full_name: SimpleGraph.dart_edge_eq_iff
code: theorem dart_edge_eq_iff : ∀ d₁ d₂ : G.Dart, d₁.edge = d₂.edge ↔ d₁ = d₂ ∨ d₁ = d₂.symm 
goal: d₁.edge = d₂.edge ↔ d₁ = d₂ ∨ d₁ = d₂.symm

full_name: SimpleGraph.dart_edge_eq_mk'_iff
code: theorem dart_edge_eq_mk'_iff :
    ∀ {d : G.Dart} {p : V × V}, d.edge = Sym2.mk p ↔ d.toProd = p ∨ d.toProd = p.swap 
goal: d.edge = Sym2.mk p ↔ d.toProd = p ∨ d.toProd = p.swap

full_name: SimpleGraph.dart_edge_eq_mk'_iff'
code: theorem dart_edge_eq_mk'_iff' :
    ∀ {d : G.Dart} {u v : V},
      d.edge = s(u, v) ↔ d.fst = u ∧ d.snd = v ∨ d.fst = v ∧ d.snd = u 
goal: d.edge = s(u, v) ↔ d.toProd.1 = u ∧ d.toProd.2 = v ∨ d.toProd.1 = v ∧ d.toProd.2 = u

full_name: SimpleGraph.DartAdj
code: /-- Two darts are said to be adjacent if they could be consecutive
darts in a walk -- that is, the first dart's second vertex is equal to
the second dart's first vertex. -/
def DartAdj (d d' : G.Dart) : Prop 
goal: Prop

full_name: SimpleGraph.dartOfNeighborSet_toProd
code: /-- For a given vertex `v`, this is the bijective map from the neighbor set at `v`
to the darts `d` with `d.fst = v`. -/
@[simps]
def dartOfNeighborSet (v : V) (w : G.neighborSet v) : G.Dart 
goal: (G.dartOfNeighborSet v w).toProd = (v, ↑w)

full_name: SimpleGraph.dartOfNeighborSet
code: /-- For a given vertex `v`, this is the bijective map from the neighbor set at `v`
to the darts `d` with `d.fst = v`. -/
@[simps]
def dartOfNeighborSet (v : V) (w : G.neighborSet v) : G.Dart 
goal: G.Dart

full_name: SimpleGraph.dartOfNeighborSet_injective
code: theorem dartOfNeighborSet_injective (v : V) : Function.Injective (G.dartOfNeighborSet v) 
goal: Function.Injective (G.dartOfNeighborSet v)

full_name: SimpleGraph.nonempty_dart_top
code: instance nonempty_dart_top [Nontrivial V] : Nonempty (⊤ : SimpleGraph V).Dart 
goal: Nonempty ⊤.Dart