url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
|---|---|---|---|---|---|---|---|---|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply congr.coinduction F r' | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ congr F x y | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ ∀ (x y : Container.M (C F)), r' x y → ↑(precongr F) r' x y
case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | . clear h₂
intro x y h₂
simp only [precongr, map_quot]
have h₂ := h₁ _ _ h₂
simp only [destruct, destruct.f] at h₂
generalize Container.M.destruct x = x at *
generalize Container.M.destruct y = y at *
cases x with | mk nx kx =>
cases y with | mk ny ky =>
let f : Quot r → Quot r' :=
by
apply Quot.lift (Quot.lift (Quot.mk r') _) _
. intro a b h₃
apply Quot.sound
simp only
rw [Quot.sound h₃]
apply h₀
. intro x; apply Quot.inductionOn (motive := _) x; clear x
intro x y; apply Quot.inductionOn (motive := _) y; clear y
intro y h
apply Quot.sound
apply h
have : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r' := rfl
conv =>
congr
. rhs
lhs
intro i
rw [←this]
rfl
. rhs
lhs
intro i
rw [←this]
rw [Container.Map_spec, Container.Map_spec, Container.Map_spec, Container.Map_spec]
rw [inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, h₂] | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ ∀ (x y : Container.M (C F)), r' x y → ↑(precongr F) r' x y
case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | . apply h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | clear h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ ∀ (x y : Container.M (C F)), r' x y → ↑(precongr F) r' x y | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ ∀ (x y : Container.M (C F)), r' x y → ↑(precongr F) r' x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | intro x y h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ ∀ (x y : Container.M (C F)), r' x y → ↑(precongr F) r' x y | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂ : r' x y
⊢ ↑(precongr F) r' x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | simp only [precongr, map_quot] | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂ : r' x y
⊢ ↑(precongr F) r' x y | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂ : r' x y
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | have h₂ := h₁ _ _ h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂ : r' x y
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
h₂ : Quot.mk r <$> destruct (Quot.mk (congr F) x) = Quot.mk r <$> destruct (Quot.mk (congr F) y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | simp only [destruct, destruct.f] at h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
h₂ : Quot.mk r <$> destruct (Quot.mk (congr F) x) = Quot.mk r <$> destruct (Quot.mk (congr F) y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct x) =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | generalize Container.M.destruct x = x at * | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct x) =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct x)) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
x : Container.Obj (C F) (Container.M (C F))
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs x =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) x) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | generalize Container.M.destruct y = y at * | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
x : Container.Obj (C F) (Container.M (C F))
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs x =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs (Container.M.destruct y)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) x) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) (Container.M.destruct y)) | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
x y : Container.Obj (C F) (Container.M (C F))
h₂ : Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs x = Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs y
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) x) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | cases x with | mk nx kx =>
cases y with | mk ny ky =>
let f : Quot r → Quot r' :=
by
apply Quot.lift (Quot.lift (Quot.mk r') _) _
. intro a b h₃
apply Quot.sound
simp only
rw [Quot.sound h₃]
apply h₀
. intro x; apply Quot.inductionOn (motive := _) x; clear x
intro x y; apply Quot.inductionOn (motive := _) y; clear y
intro y h
apply Quot.sound
apply h
have : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r' := rfl
conv =>
congr
. rhs
lhs
intro i
rw [←this]
rfl
. rhs
lhs
intro i
rw [←this]
rw [Container.Map_spec, Container.Map_spec, Container.Map_spec, Container.Map_spec]
rw [inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, h₂] | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
x y : Container.Obj (C F) (Container.M (C F))
h₂ : Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs x = Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs y
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) x) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) y) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | cases y with | mk ny ky =>
let f : Quot r → Quot r' :=
by
apply Quot.lift (Quot.lift (Quot.mk r') _) _
. intro a b h₃
apply Quot.sound
simp only
rw [Quot.sound h₃]
apply h₀
. intro x; apply Quot.inductionOn (motive := _) x; clear x
intro x y; apply Quot.inductionOn (motive := _) y; clear y
intro y h
apply Quot.sound
apply h
have : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r' := rfl
conv =>
congr
. rhs
lhs
intro i
rw [←this]
rfl
. rhs
lhs
intro i
rw [←this]
rw [Container.Map_spec, Container.Map_spec, Container.Map_spec, Container.Map_spec]
rw [inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, h₂] | case a.a.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y✝ : Container.M (C F)
h₂✝ : r' x y✝
y : Container.Obj (C F) (Container.M (C F))
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs y
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) y) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | let f : Quot r → Quot r' :=
by
apply Quot.lift (Quot.lift (Quot.mk r') _) _
. intro a b h₃
apply Quot.sound
simp only
rw [Quot.sound h₃]
apply h₀
. intro x; apply Quot.inductionOn (motive := _) x; clear x
intro x y; apply Quot.inductionOn (motive := _) y; clear y
intro y h
apply Quot.sound
apply h | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := ny, snd := ky }) | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := ny, snd := ky }) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | have : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r' := rfl | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := ny, snd := ky }) | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := ny, snd := ky }) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | conv =>
congr
. rhs
lhs
intro i
rw [←this]
rfl
. rhs
lhs
intro i
rw [←this] | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := nx, snd := kx }) =
abs (Container.Map (Quot.mk fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)) { fst := ny, snd := ky }) | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map (fun i => (f ∘ Quot.mk r ∘ Quot.mk (congr F)) i) { fst := nx, snd := kx }) =
abs (Container.Map (fun i => (f ∘ Quot.mk r ∘ Quot.mk (congr F)) i) { fst := ny, snd := ky }) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | rw [Container.Map_spec, Container.Map_spec, Container.Map_spec, Container.Map_spec] | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map (fun i => (f ∘ Quot.mk r ∘ Quot.mk (congr F)) i) { fst := nx, snd := kx }) =
abs (Container.Map (fun i => (f ∘ Quot.mk r ∘ Quot.mk (congr F)) i) { fst := ny, snd := ky }) | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map f (Container.Map (Quot.mk r) (Container.Map (Quot.mk (congr F)) { fst := nx, snd := kx }))) =
abs (Container.Map f (Container.Map (Quot.mk r) (Container.Map (Quot.mk (congr F)) { fst := ny, snd := ky }))) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | rw [inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, inst.abs_map, h₂] | case a.a.mk.mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
f : Quot r → Quot r' :=
Quot.lift (Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b))
(_ :
∀ (x b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b)
this : f ∘ Quot.mk r ∘ Quot.mk (congr F) = Quot.mk r'
⊢ abs (Container.Map f (Container.Map (Quot.mk r) (Container.Map (Quot.mk (congr F)) { fst := nx, snd := kx }))) =
abs (Container.Map f (Container.Map (Quot.mk r) (Container.Map (Quot.mk (congr F)) { fst := ny, snd := ky }))) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply Quot.lift (Quot.lift (Quot.mk r') _) _ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ Quot r → Quot r' | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Quot (congr F)), r a b → Quot.lift (Quot.mk r') ?m.11689 a = Quot.lift (Quot.mk r') ?m.11689 b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | . intro a b h₃
apply Quot.sound
simp only
rw [Quot.sound h₃]
apply h₀ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Quot (congr F)), r a b → Quot.lift (Quot.mk r') ?m.11689 a = Quot.lift (Quot.mk r') ?m.11689 b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Quot (congr F)),
r a b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) a =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | . intro x; apply Quot.inductionOn (motive := _) x; clear x
intro x y; apply Quot.inductionOn (motive := _) y; clear y
intro y h
apply Quot.sound
apply h | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Quot (congr F)),
r a b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) a =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | intro a b h₃ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ Quot.mk r' a = Quot.mk r' b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply Quot.sound | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ Quot.mk r' a = Quot.mk r' b | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r' a b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | simp only | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r' a b | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r (Quot.mk (congr F) a) (Quot.mk (congr F) b) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | rw [Quot.sound h₃] | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r (Quot.mk (congr F) a) (Quot.mk (congr F) b) | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r (Quot.mk (congr F) b) (Quot.mk (congr F) b) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply h₀ | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
a b : Container.M (C F)
h₃ : congr F a b
⊢ r (Quot.mk (congr F) b) (Quot.mk (congr F) b) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | intro x | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a b : Quot (congr F)),
r a b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) a =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Quot (congr F)
⊢ ∀ (b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply Quot.inductionOn (motive := _) x | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Quot (congr F)
⊢ ∀ (b : Quot (congr F)),
r x b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) x =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Quot (congr F)
⊢ ∀ (a : Container.M (C F)) (b : Quot (congr F)),
r (Quot.mk (congr F) a) b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | clear x | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Quot (congr F)
⊢ ∀ (a : Container.M (C F)) (b : Quot (congr F)),
r (Quot.mk (congr F) a) b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a : Container.M (C F)) (b : Quot (congr F)),
r (Quot.mk (congr F) a) b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | intro x y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x y : Container.M (C F)
h₂✝ : r' x y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
⊢ ∀ (a : Container.M (C F)) (b : Quot (congr F)),
r (Quot.mk (congr F) a) b →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) b | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
y : Quot (congr F)
⊢ r (Quot.mk (congr F) x) y →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply Quot.inductionOn (motive := _) y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
y : Quot (congr F)
⊢ r (Quot.mk (congr F) x) y →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b) y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
y : Quot (congr F)
⊢ ∀ (a : Container.M (C F)),
r (Quot.mk (congr F) x) (Quot.mk (congr F) a) →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | clear y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
y : Quot (congr F)
⊢ ∀ (a : Container.M (C F)),
r (Quot.mk (congr F) x) (Quot.mk (congr F) a) →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
⊢ ∀ (a : Container.M (C F)),
r (Quot.mk (congr F) x) (Quot.mk (congr F) a) →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | intro y h | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y : Container.M (C F)
h₂✝ : r' x✝ y
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x : Container.M (C F)
⊢ ∀ (a : Container.M (C F)),
r (Quot.mk (congr F) x) (Quot.mk (congr F) a) →
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) a) | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x y : Container.M (C F)
h : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply Quot.sound | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x y : Container.M (C F)
h : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) x) =
Quot.lift (Quot.mk r') (_ : ∀ (a b : Container.M (C F)), congr F a b → Quot.mk r' a = Quot.mk r' b)
(Quot.mk (congr F) y) | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x y : Container.M (C F)
h : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply h | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x✝¹ y✝¹ : Container.M (C F)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
x✝ y✝ : Container.M (C F)
h₂✝ : r' x✝ y✝
nx : (C F).A
kx : Container.B (C F) nx → Container.M (C F)
ny : (C F).A
ky : Container.B (C F) ny → Container.M (C F)
h₂ :
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := nx, snd := kx } =
Quot.mk r <$> (fun x => Quot.mk (congr F) x) <$> abs { fst := ny, snd := ky }
x y : Container.M (C F)
h : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim_lemma | [135, 1] | [187, 13] | apply h₂ | case a.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x : M F), r x x
h₁ : ∀ (x y : M F), r x y → Quot.mk r <$> destruct x = Quot.mk r <$> destruct y
x y : Container.M (C F)
h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
r' : Container.M (C F) → Container.M (C F) → Prop := fun x y => r (Quot.mk (congr F) x) (Quot.mk (congr F) y)
⊢ r' x y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | intro x y h₁ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
⊢ ∀ (x y : M F), r x y → x = y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | apply bisim_lemma (λ x y => x = y ∨ r x y) | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y | case h₀
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x : M F), x = x ∨ r x x
case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x y : M F),
x = y ∨ r x y →
(Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y
case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | . intro _
left
rfl | case h₀
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x : M F), x = x ∨ r x x
case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x y : M F),
x = y ∨ r x y →
(Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y
case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y | case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x y : M F),
x = y ∨ r x y →
(Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y
case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | . intro x y h₂
cases h₂
case inl h₂ =>
rw [h₂]
case inr h₂ =>
have ⟨z, h₃⟩ := h₀ _ _ h₂
clear h₂
rw [←h₃.1, ←h₃.2]
clear h₃
rw [←map_comp, ←map_comp]
conv =>
congr <;> rw [←abs_repr z]
rw [←abs_map]
rw [←abs_map]
cases repr z with | mk nz kz =>
simp only [Container.Map, Function.comp]
apply congrArg abs
rw [Container.Obj.snd_equals_iff]
funext a
apply Quot.sound
right
apply (kz a).2 | case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x y : M F),
x = y ∨ r x y →
(Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y
case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | . right; assumption | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | intro _ | case h₀
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x : M F), x = x ∨ r x x | case h₀
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
x✝ : M F
⊢ x✝ = x✝ ∨ r x✝ x✝ |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | left | case h₀
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
x✝ : M F
⊢ x✝ = x✝ ∨ r x✝ x✝ | case h₀.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
x✝ : M F
⊢ x✝ = x✝ |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rfl | case h₀.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
x✝ : M F
⊢ x✝ = x✝ | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | intro x y h₂ | case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ ∀ (x y : M F),
x = y ∨ r x y →
(Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : x = y ∨ r x y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | cases h₂ | case h₁
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : x = y ∨ r x y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | case h₁.inl
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h✝ : x = y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y
case h₁.inr
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h✝ : r x y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | case inl h₂ =>
rw [h₂] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : x = y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | case inr h₂ =>
have ⟨z, h₃⟩ := h₀ _ _ h₂
clear h₂
rw [←h₃.1, ←h₃.2]
clear h₃
rw [←map_comp, ←map_comp]
conv =>
congr <;> rw [←abs_repr z]
rw [←abs_map]
rw [←abs_map]
cases repr z with | mk nz kz =>
simp only [Container.Map, Function.comp]
apply congrArg abs
rw [Container.Obj.snd_equals_iff]
funext a
apply Quot.sound
right
apply (kz a).2 | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : r x y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [h₂] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : x = y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | have ⟨z, h₃⟩ := h₀ _ _ h₂ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : r x y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : r x y
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | clear h₂ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
h₂ : r x y
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [←h₃.1, ←h₃.2] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> destruct x = (Quot.mk fun x y => x = y ∨ r x y) <$> destruct y | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).fst) <$> z =
(Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).snd) <$> z |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | clear h₃ | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
h₃ : (fun x => (↑x).fst) <$> z = destruct x ∧ (fun x => (↑x).snd) <$> z = destruct y
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).fst) <$> z =
(Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).snd) <$> z | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).fst) <$> z =
(Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).snd) <$> z |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [←map_comp, ←map_comp] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ (Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).fst) <$> z =
(Quot.mk fun x y => x = y ∨ r x y) <$> (fun x => (↑x).snd) <$> z | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) <$> z =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> z |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | conv =>
congr <;> rw [←abs_repr z] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) <$> z =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> z | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) <$> abs (repr z) =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> abs (repr z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [←abs_map] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) <$> abs (repr z) =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> abs (repr z) | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) (repr z)) =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> abs (repr z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [←abs_map] | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) (repr z)) =
((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) <$> abs (repr z) | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) (repr z)) =
abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) (repr z)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | cases repr z with | mk nz kz =>
simp only [Container.Map, Function.comp]
apply congrArg abs
rw [Container.Obj.snd_equals_iff]
funext a
apply Quot.sound
right
apply (kz a).2 | F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
⊢ abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) (repr z)) =
abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) (repr z)) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | simp only [Container.Map, Function.comp] | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).fst) { fst := nz, snd := kz }) =
abs (Container.Map ((Quot.mk fun x y => x = y ∨ r x y) ∘ fun x => (↑x).snd) { fst := nz, snd := kz }) | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ abs { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst } =
abs { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | apply congrArg abs | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ abs { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst } =
abs { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd } | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst } =
{ fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | rw [Container.Obj.snd_equals_iff] | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ { fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst } =
{ fst := nz, snd := fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd } | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ (fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst) = fun x =>
Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | funext a | case mk
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
⊢ (fun x => Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).fst) = fun x =>
Quot.mk (fun x y => x = y ∨ r x y) (↑(kz x)).snd | case mk.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ Quot.mk (fun x y => x = y ∨ r x y) (↑(kz a)).fst = Quot.mk (fun x y => x = y ∨ r x y) (↑(kz a)).snd |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | apply Quot.sound | case mk.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ Quot.mk (fun x y => x = y ∨ r x y) (↑(kz a)).fst = Quot.mk (fun x y => x = y ∨ r x y) (↑(kz a)).snd | case mk.h.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ (↑(kz a)).fst = (↑(kz a)).snd ∨ r (↑(kz a)).fst (↑(kz a)).snd |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | right | case mk.h.a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ (↑(kz a)).fst = (↑(kz a)).snd ∨ r (↑(kz a)).fst (↑(kz a)).snd | case mk.h.a.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ r (↑(kz a)).fst (↑(kz a)).snd |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | apply (kz a).2 | case mk.h.a.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x✝ y✝ : M F
h₁ : r x✝ y✝
x y : M F
z : F { p // r p.fst p.snd }
nz : (C F).A
kz : Container.B (C F) nz → { p // r p.fst p.snd }
a : Container.B (C F) nz
⊢ r (↑(kz a)).fst (↑(kz a)).snd | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | right | case a
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ x = y ∨ r x y | case a.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ r x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/M.lean | QPF.M.bisim | [191, 1] | [221, 22] | assumption | case a.h
F : Type u₁ → Type u₁
inst : QPF F
r : M F → M F → Prop
h₀ : ∀ (x y : M F), r x y → liftr F r (destruct x) (destruct y)
x y : M F
h₁ : r x y
⊢ r x y | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | apply Iff.intro | m n : Nat
⊢ m = n ↔ I m = I n | case mp
m n : Nat
⊢ m = n → I m = I n
case mpr
m n : Nat
⊢ I m = I n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | intro h | case mp
m n : Nat
⊢ m = n → I m = I n
case mpr
m n : Nat
⊢ I m = I n → m = n | case mp
m n : Nat
h : m = n
⊢ I m = I n
case mpr
m n : Nat
⊢ I m = I n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | exact congrArg I h | case mp
m n : Nat
h : m = n
⊢ I m = I n
case mpr
m n : Nat
⊢ I m = I n → m = n | case mpr
m n : Nat
⊢ I m = I n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | intro h | case mpr
m n : Nat
⊢ I m = I n → m = n | case mpr
m n : Nat
h : I m = I n
⊢ m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | cases h | case mpr
m n : Nat
h : I m = I n
⊢ m = n | case mpr.refl
m : Nat
⊢ m = m |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_I_Nat | [51, 1] | [57, 6] | rfl | case mpr.refl
m : Nat
⊢ m = m | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | apply Iff.intro | m n : Nat
⊢ m = n ↔ Is m = Is n | case mp
m n : Nat
⊢ m = n → Is m = Is n
case mpr
m n : Nat
⊢ Is m = Is n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | intro h | case mp
m n : Nat
⊢ m = n → Is m = Is n
case mpr
m n : Nat
⊢ Is m = Is n → m = n | case mp
m n : Nat
h : m = n
⊢ Is m = Is n
case mpr
m n : Nat
⊢ Is m = Is n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | exact congrArg Is h | case mp
m n : Nat
h : m = n
⊢ Is m = Is n
case mpr
m n : Nat
⊢ Is m = Is n → m = n | case mpr
m n : Nat
⊢ Is m = Is n → m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | intro h | case mpr
m n : Nat
⊢ Is m = Is n → m = n | case mpr
m n : Nat
h : Is m = Is n
⊢ m = n |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | cases h | case mpr
m n : Nat
h : Is m = Is n
⊢ m = n | case mpr.refl
m : Nat
⊢ m = m |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/EllipticCurve/KodairaTypes.lean | eq_Is_Nat | [59, 1] | [65, 6] | rfl | case mpr.refl
m : Nat
⊢ m = m | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | mod_mod | [23, 1] | [26, 8] | sorry | K : Type u_1
a b : K
inst✝ : EuclideanDomain K
⊢ a % b % b = a % b | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.p_non_zero | [86, 1] | [88, 7] | rw [←nav.v_eq_top_iff_zero, nav.v_uniformizer] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ ¬p = 0 | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ ¬1 = ⊤ |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.p_non_zero | [86, 1] | [88, 7] | simp | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ ¬1 = ⊤ | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_mul_ge_right | [96, 1] | [98, 32] | rw [mul_comm] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
a b : R
⊢ v nav b ≤ v nav (a * b) | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
a b : R
⊢ v nav b ≤ v nav (b * a) |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_mul_ge_right | [96, 1] | [98, 32] | exact val_mul_ge_left nav b a | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
a b : R
⊢ v nav b ≤ v nav (b * a) | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_mul_ge_of_both_ge | [108, 1] | [111, 25] | rw [nav.v_mul_eq_add_v] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m n : ℕ∞
p : R
nav : SurjVal p
a b : R
ha : m ≤ v nav a
hb : n ≤ v nav b
⊢ m + n ≤ v nav (a * b) | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m n : ℕ∞
p : R
nav : SurjVal p
a b : R
ha : m ≤ v nav a
hb : n ≤ v nav b
⊢ m + n ≤ v nav a + v nav b |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_mul_ge_of_both_ge | [108, 1] | [111, 25] | exact add_le_add ha hb | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m n : ℕ∞
p : R
nav : SurjVal p
a b : R
ha : m ≤ v nav a
hb : n ≤ v nav b
⊢ m + n ≤ v nav a + v nav b | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_one | [113, 1] | [126, 10] | dsimp | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ (fun x => x + v nav p) (v nav 1) = (fun x => x + v nav p) 0 | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ v nav 1 + v nav p = 0 + v nav p |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_one | [113, 1] | [126, 10] | rw [← v_mul_eq_add_v] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ v nav 1 + v nav p = 0 + v nav p | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ v nav (1 * p) = 0 + v nav p |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_one | [113, 1] | [126, 10] | simp | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ v nav (1 * p) = 0 + v nav p | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_one | [113, 1] | [126, 10] | intro x y h | case inj
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ Function.Injective fun x => x + v nav p | case inj
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
x y : ℕ∞
h : (fun x => x + v nav p) x = (fun x => x + v nav p) y
⊢ x = y |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_one | [113, 1] | [126, 10] | induction x using ENat.recTopCoe <;>
induction y using ENat.recTopCoe <;>
simp at * <;>
sorry | case inj
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
x y : ℕ∞
h : (fun x => x + v nav p) x = (fun x => x + v nav p) y
⊢ x = y | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_ge_of_ge | [128, 1] | [134, 40] | induction k with
| zero => simp [zero_nsmul]
| succ k ih =>
simp only [succ_nsmul, pow_succ]
apply val_mul_ge_of_both_ge _ ha ih | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
k : ℕ
ha : m ≤ v nav a
⊢ k • m ≤ v nav (a ^ k) | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_ge_of_ge | [128, 1] | [134, 40] | simp [zero_nsmul] | case zero
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : m ≤ v nav a
⊢ Nat.zero • m ≤ v nav (a ^ Nat.zero) | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_ge_of_ge | [128, 1] | [134, 40] | simp only [succ_nsmul, pow_succ] | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : m ≤ v nav a
k : ℕ
ih : k • m ≤ v nav (a ^ k)
⊢ Nat.succ k • m ≤ v nav (a ^ Nat.succ k) | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : m ≤ v nav a
k : ℕ
ih : k • m ≤ v nav (a ^ k)
⊢ m + k • m ≤ v nav (a * a ^ k) |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_ge_of_ge | [128, 1] | [134, 40] | apply val_mul_ge_of_both_ge _ ha ih | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : m ≤ v nav a
k : ℕ
ih : k • m ≤ v nav (a ^ k)
⊢ m + k • m ≤ v nav (a * a ^ k) | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_eq_of_eq | [136, 1] | [142, 36] | induction k with
| zero => simp
| succ k ih =>
simp only [pow_succ, Nat.cast_succ, add_mul, one_mul, add_comm]
rw [nav.v_mul_eq_add_v, ha, ih] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
k : ℕ
ha : v nav a = m
⊢ v nav (a ^ k) = ↑k * m | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_eq_of_eq | [136, 1] | [142, 36] | simp | case zero
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : v nav a = m
⊢ v nav (a ^ Nat.zero) = ↑Nat.zero * m | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_eq_of_eq | [136, 1] | [142, 36] | simp only [pow_succ, Nat.cast_succ, add_mul, one_mul, add_comm] | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : v nav a = m
k : ℕ
ih : v nav (a ^ k) = ↑k * m
⊢ v nav (a ^ Nat.succ k) = ↑(Nat.succ k) * m | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : v nav a = m
k : ℕ
ih : v nav (a ^ k) = ↑k * m
⊢ v nav (a * a ^ k) = m + ↑k * m |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_pow_eq_of_eq | [136, 1] | [142, 36] | rw [nav.v_mul_eq_add_v, ha, ih] | case succ
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
m : ℕ∞
p : R
nav : SurjVal p
a : R
ha : v nav a = m
k : ℕ
ih : v nav (a ^ k) = ↑k * m
⊢ v nav (a * a ^ k) = m + ↑k * m | no goals |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_minus_one | [164, 1] | [170, 16] | by_contra | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
⊢ v nav (-1) = 0 | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
x✝ : ¬v nav (-1) = 0
⊢ False |
https://github.com/KisaraBlue/ec-tate-lean.git | b9d36a5b70bb0958bf9741ae6216a43b35c87ed4 | ECTate/Algebra/ValuedRing.lean | SurjVal.val_of_minus_one | [164, 1] | [170, 16] | have contradiction : nav 1 > 0 := by
rw [←neg_neg 1, ←one_mul 1, neg_mul_eq_neg_mul, neg_mul_eq_mul_neg, nav.v_mul_eq_add_v]
simpa [pos_iff_ne_zero] | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
x✝ : ¬v nav (-1) = 0
⊢ False | R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
nav : SurjVal p
x✝ : ¬v nav (-1) = 0
contradiction : v nav 1 > 0
⊢ False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.