Datasets:

internlm
/

Lean-Github

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 219k rows

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/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply congr.coinduction r'	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ congr F i x y	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ ∀ (i : I) (x y : IContainer.M (C F) i), r' i x y → ↑(precongr F) r' i x y case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	. clear h₂ intro i x y h₂ simp only [precongr, map_quot] have h₂ := h₁ i _ _ h₂ simp only [destruct, destruct.f] at h₂ generalize IContainer.M.destruct x = x at * generalize IContainer.M.destruct y = y at * cases x with \| mk nx kx => cases y with \| mk ny ky => let f i : Quot (r i) → Quot (r' i) := 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 : ∀ i, f i ∘ Quot.mk (r _) ∘ Quot.mk (congr F _) = Quot.mk (r' _) := by intro i; rfl conv => congr . rhs lhs intro i rw [←this] rfl . rhs lhs intro i rw [←this] rw [IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec] rw [inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, h₂]	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ ∀ (i : I) (x y : IContainer.M (C F) i), r' i x y → ↑(precongr F) r' i x y case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	. apply h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	clear h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ ∀ (i : I) (x y : IContainer.M (C F) i), r' i x y → ↑(precongr F) r' i x y	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ ∀ (i : I) (x y : IContainer.M (C F) i), r' i x y → ↑(precongr F) r' i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro i x y h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ ∀ (i : I) (x y : IContainer.M (C F) i), r' i x y → ↑(precongr F) r' i x y	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂ : r' i x y ⊢ ↑(precongr F) r' i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	simp only [precongr, map_quot]	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂ : r' i x y ⊢ ↑(precongr F) r' i x y	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂ : r' i x y ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	have h₂ := h₁ i _ _ h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂ : r' i x y ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (destruct (Quot.mk (congr F i) x)) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct (Quot.mk (congr F i) y)) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	simp only [destruct, destruct.f] at h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (destruct (Quot.mk (congr F i) x)) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct (Quot.mk (congr F i) y)) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct x))) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct y))) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	generalize IContainer.M.destruct x = x at *	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct x))) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct y))) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct x)) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝¹ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x✝ y : IContainer.M (C F) i h₂✝ : r' i x✝ y x : IContainer.Obj (C F) (IContainer.M (C F)) i h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs x)) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct y))) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) x) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	generalize IContainer.M.destruct y = y at *	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝¹ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x✝ y : IContainer.M (C F) i h₂✝ : r' i x✝ y x : IContainer.Obj (C F) (IContainer.M (C F)) i h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs x)) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs (IContainer.M.destruct y))) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) x) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) (IContainer.M.destruct y))	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝¹ y✝¹ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x✝ y✝ : IContainer.M (C F) i h₂✝ : r' i x✝ y✝ x y : IContainer.Obj (C F) (IContainer.M (C F)) i h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs x)) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs y)) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) x) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	cases x with \| mk nx kx => cases y with \| mk ny ky => let f i : Quot (r i) → Quot (r' i) := 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 : ∀ i, f i ∘ Quot.mk (r _) ∘ Quot.mk (congr F _) = Quot.mk (r' _) := by intro i; rfl conv => congr . rhs lhs intro i rw [←this] rfl . rhs lhs intro i rw [←this] rw [IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec] rw [inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, h₂]	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝¹ y✝¹ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x✝ y✝ : IContainer.M (C F) i h₂✝ : r' i x✝ y✝ x y : IContainer.Obj (C F) (IContainer.M (C F)) i h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs x)) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs y)) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) x) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) y)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	cases y with \| mk ny ky => let f i : Quot (r i) → Quot (r' i) := 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 : ∀ i, f i ∘ Quot.mk (r _) ∘ Quot.mk (congr F _) = Quot.mk (r' _) := by intro i; rfl conv => congr . rhs lhs intro i rw [←this] rfl . rhs lhs intro i rw [←this] rw [IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec] rw [inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, h₂]	case a.a.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝¹ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y✝ : IContainer.M (C F) i h₂✝ : r' i x y✝ y : IContainer.Obj (C F) (IContainer.M (C F)) i nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs y)) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) y)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	let f i : Quot (r i) → Quot (r' i) := 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 I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := ny, snd := ky })	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := ny, snd := ky })
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	have : ∀ i, f i ∘ Quot.mk (r _) ∘ Quot.mk (congr F _) = Quot.mk (r' _) := by intro i; rfl	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := ny, snd := ky })	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := ny, snd := ky })
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	conv => congr . rhs lhs intro i rw [←this] rfl . rhs lhs intro i rw [←this]	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => Quot.mk fun x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)) { fst := ny, snd := ky })	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i)) { fst := ny, snd := ky })
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	rw [IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec, IContainer.Map_spec]	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i)) { fst := nx, snd := kx }) = abs (IContainer.Map (fun i => f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i)) { fst := ny, snd := ky })	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => f i) (IContainer.Map (fun i => Quot.mk (r i)) (IContainer.Map (fun i => Quot.mk (congr F i)) { fst := nx, snd := kx }))) = abs (IContainer.Map (fun i => f i) (IContainer.Map (fun i => Quot.mk (r i)) (IContainer.Map (fun i => Quot.mk (congr F i)) { fst := ny, snd := ky })))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	rw [inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, inst.abs_imap, h₂]	case a.a.mk.mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) this : ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i) ⊢ abs (IContainer.Map (fun i => f i) (IContainer.Map (fun i => Quot.mk (r i)) (IContainer.Map (fun i => Quot.mk (congr F i)) { fst := nx, snd := kx }))) = abs (IContainer.Map (fun i => f i) (IContainer.Map (fun i => Quot.mk (r i)) (IContainer.Map (fun i => Quot.mk (congr F i)) { fst := ny, snd := ky })))	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply Quot.lift (Quot.lift (Quot.mk (r' _)) _) _	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ Quot (r i) → Quot (r' i)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : Quot (congr F i)), r i a b → Quot.lift (Quot.mk (r' i)) ?m.25601 a = Quot.lift (Quot.mk (r' i)) ?m.25601 b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	. intro a b h₃ apply Quot.sound simp only rw [Quot.sound h₃] apply h₀	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : Quot (congr F i)), r i a b → Quot.lift (Quot.mk (r' i)) ?m.25601 a = Quot.lift (Quot.mk (r' i)) ?m.25601 b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : Quot (congr F i)), r i a b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) a = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 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	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : Quot (congr F i)), r i a b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) a = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro a b h₃	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ Quot.mk (r' i) a = Quot.mk (r' i) b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply Quot.sound	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ Quot.mk (r' i) a = Quot.mk (r' i) b	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r' i a b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	simp only	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r' i a b	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r i (Quot.mk (congr F i) a) (Quot.mk (congr F i) b)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	rw [Quot.sound h₃]	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r i (Quot.mk (congr F i) a) (Quot.mk (congr F i) b)	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r i (Quot.mk (congr F i) b) (Quot.mk (congr F i) b)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply h₀	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I a b : IContainer.M (C F) i h₃ : congr F i a b ⊢ r i (Quot.mk (congr F i) b) (Quot.mk (congr F i) b)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro x	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a b : Quot (congr F i)), r i a b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) a = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : Quot (congr F i) ⊢ ∀ (b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply Quot.inductionOn (motive := _) x	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : Quot (congr F i) ⊢ ∀ (b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : Quot (congr F i) ⊢ ∀ (a : IContainer.M (C F) i) (b : Quot (congr F i)), r i (Quot.mk (congr F i) a) b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	clear x	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : Quot (congr F i) ⊢ ∀ (a : IContainer.M (C F) i) (b : Quot (congr F i)), r i (Quot.mk (congr F i) a) b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a : IContainer.M (C F) i) (b : Quot (congr F i)), r i (Quot.mk (congr F i) a) b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro x y	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I ⊢ ∀ (a : IContainer.M (C F) i) (b : Quot (congr F i)), r i (Quot.mk (congr F i) a) b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i y : Quot (congr F i) ⊢ r i (Quot.mk (congr F i) x) y → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply Quot.inductionOn (motive := _) y	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i y : Quot (congr F i) ⊢ r i (Quot.mk (congr F i) x) y → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) y	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i y : Quot (congr F i) ⊢ ∀ (a : IContainer.M (C F) i), r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	clear y	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i y : Quot (congr F i) ⊢ ∀ (a : IContainer.M (C F) i), r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i ⊢ ∀ (a : IContainer.M (C F) i), r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro y h	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x : IContainer.M (C F) i ⊢ ∀ (a : IContainer.M (C F) i), r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) a)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x y : IContainer.M (C F) i h : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply Quot.sound	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x y : IContainer.M (C F) i h : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) x) = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) (Quot.mk (congr F i) y)	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x y : IContainer.M (C F) i h : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply h	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝¹ y✝¹ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ h₂✝ : r' i✝ x✝ y✝ nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) i : I x y : IContainer.M (C F) i h : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	intro i	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝ : I x✝ y✝ : IContainer.M (C F) i✝ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i : I x y : IContainer.M (C F) i h₂✝ : r' i x y nx : IContainer.A (C F) i kx : (y : IContainer.B (C F) i nx) → IContainer.M (C F) (IContainer.N (C F) i nx y) ny : IContainer.A (C F) i ky : (y : IContainer.B (C F) i ny) → IContainer.M (C F) (IContainer.N (C F) i ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) ⊢ ∀ (i : I), f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) i : I ⊢ f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	rfl	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i✝¹ : I x✝ y✝ : IContainer.M (C F) i✝¹ r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) i✝ : I x y : IContainer.M (C F) i✝ h₂✝ : r' i✝ x y nx : IContainer.A (C F) i✝ kx : (y : IContainer.B (C F) i✝ nx) → IContainer.M (C F) (IContainer.N (C F) i✝ nx y) ny : IContainer.A (C F) i✝ ky : (y : IContainer.B (C F) i✝ ny) → IContainer.M (C F) (IContainer.N (C F) i✝ ny y) h₂ : IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := nx, snd := kx })) = IFunctor.imap (fun i => Quot.mk (r i)) (IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1) (abs { fst := ny, snd := ky })) f : (i : I) → Quot (r i) → Quot (r' i) := fun i => Quot.lift (Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b)) (_ : ∀ (x b : Quot (congr F i)), r i x b → Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) x = Quot.lift (Quot.mk (r' i)) (_ : ∀ (a b : IContainer.M (C F) i), congr F i a b → Quot.mk (r' i) a = Quot.mk (r' i) b) b) i : I ⊢ f i ∘ Quot.mk (r i) ∘ Quot.mk (congr F i) = Quot.mk (r' i)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim_lemma	[131, 1]	[183, 13]	apply h₂	case a.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x : M F i), r i x x h₁ : ∀ (i : I) (x y : M F i), r i x y → IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y) i : I x y : IContainer.M (C F) i h₂ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) r' : (i : I) → IContainer.M (C F) i → IContainer.M (C F) i → Prop := fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y) ⊢ r' i x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	intro i x y h₁	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) ⊢ ∀ {i : I} (x y : M F i), r i x y → x = y	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	apply bisim_lemma (λ i x y => x = y ∨ r i x y)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y	case h₀ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x : M F i), x = x ∨ r i x x case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x y : M F i), x = y ∨ r i x y → IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y) case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	. intro _ _ left rfl	case h₀ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x : M F i), x = x ∨ r i x x case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x y : M F i), x = y ∨ r i x y → IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y) case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y	case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x y : M F i), x = y ∨ r i x y → IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y) case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	. intro i 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 [←imap_spec, ←imap_spec] conv => congr <;> rw [←abs_repr z] rw [←abs_imap] rw [←abs_imap] cases repr z with \| mk nz kz => simp only [IContainer.Map, Function.comp] apply congrArg abs rw [Sigma.mk.inj_iff] simp only [true_and, heq_eq_eq] funext a apply Quot.sound right apply (kz a).2	case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x y : M F i), x = y ∨ r i x y → IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y) case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	. right; assumption	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	intro _ _	case h₀ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x : M F i), x = x ∨ r i x x	case h₀ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y i✝ : I x✝ : M F i✝ ⊢ x✝ = x✝ ∨ r i✝ x✝ x✝
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	left	case h₀ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y i✝ : I x✝ : M F i✝ ⊢ x✝ = x✝ ∨ r i✝ x✝ x✝	case h₀.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y i✝ : I x✝ : M F i✝ ⊢ x✝ = x✝
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rfl	case h₀.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y i✝ : I x✝ : M F i✝ ⊢ x✝ = x✝	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	intro i x y h₂	case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ ∀ (i : I) (x y : M F i), x = y ∨ r i x y → IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : x = y ∨ r i x y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	cases h₂	case h₁ I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : x = y ∨ r i x y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	case h₁.inl I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h✝ : x = y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y) case h₁.inr I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h✝ : r i x y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	case inl h₂ => rw [h₂]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : x = y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	case inr h₂ => have ⟨z, h₃⟩ := h₀ _ _ _ h₂ clear h₂ rw [←h₃.1, ←h₃.2] clear h₃ rw [←imap_spec, ←imap_spec] conv => congr <;> rw [←abs_repr z] rw [←abs_imap] rw [←abs_imap] cases repr z with \| mk nz kz => simp only [IContainer.Map, Function.comp] apply congrArg abs rw [Sigma.mk.inj_iff] simp only [true_and, heq_eq_eq] funext a apply Quot.sound right apply (kz a).2	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : r i x y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [h₂]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : x = y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	have ⟨z, h₃⟩ := h₀ _ _ _ h₂	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : r i x y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : r i x y z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	clear h₂	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i h₂ : r i x y z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [←h₃.1, ←h₃.2]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct x) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (destruct y)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).fst) z) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).snd) z)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	clear h₃	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i h₃ : IFunctor.imap (fun x x_1 => (↑x_1).fst) z = destruct x ∧ IFunctor.imap (fun x x_1 => (↑x_1).snd) z = destruct y ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).fst) z) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).snd) z)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).fst) z) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).snd) z)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [←imap_spec, ←imap_spec]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).fst) z) = IFunctor.imap (fun i => Quot.mk fun x y => x = y ∨ r i x y) (IFunctor.imap (fun x x_1 => (↑x_1).snd) z)	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) z = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) z
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	conv => congr <;> rw [←abs_repr z]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) z = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) z	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (abs (repr z)) = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (abs (repr z))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [←abs_imap]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (abs (repr z)) = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (abs (repr z))	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (repr z)) = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (abs (repr z))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [←abs_imap]	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (repr z)) = IFunctor.imap (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (abs (repr z))	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (repr z)) = abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (repr z))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	cases repr z with \| mk nz kz => simp only [IContainer.Map, Function.comp] apply congrArg abs rw [Sigma.mk.inj_iff] simp only [true_and, heq_eq_eq] funext a apply Quot.sound right apply (kz a).2	I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i ⊢ abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) (repr z)) = abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) (repr z))	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	simp only [IContainer.Map, Function.comp]	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).fst) { fst := nz, snd := kz }) = abs (IContainer.Map (fun i => (Quot.mk fun x y => x = y ∨ r i x y) ∘ fun x => (↑x).snd) { fst := nz, snd := kz })	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ abs { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst } = abs { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd }
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	apply congrArg abs	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ abs { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst } = abs { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd }	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst } = { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd }
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	rw [Sigma.mk.inj_iff]	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst } = { fst := nz, snd := fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd }	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ nz = nz ∧ HEq (fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst) fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	simp only [true_and, heq_eq_eq]	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ nz = nz ∧ HEq (fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst) fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ (fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst) = fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	funext a	case mk I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) ⊢ (fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).fst) = fun y => Quot.mk (fun x y_1 => x = y_1 ∨ r (IContainer.N (C F) i nz y) x y_1) (↑(kz y)).snd	case mk.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ Quot.mk (fun x y => x = y ∨ r (IContainer.N (C F) i nz a) x y) (↑(kz a)).fst = Quot.mk (fun x y => x = y ∨ r (IContainer.N (C F) i nz a) x y) (↑(kz a)).snd
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	apply Quot.sound	case mk.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ Quot.mk (fun x y => x = y ∨ r (IContainer.N (C F) i nz a) x y) (↑(kz a)).fst = Quot.mk (fun x y => x = y ∨ r (IContainer.N (C F) i nz a) x y) (↑(kz a)).snd	case mk.h.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ (↑(kz a)).fst = (↑(kz a)).snd ∨ r (IContainer.N (C F) i nz a) (↑(kz a)).fst (↑(kz a)).snd
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	right	case mk.h.a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ (↑(kz a)).fst = (↑(kz a)).snd ∨ r (IContainer.N (C F) i nz a) (↑(kz a)).fst (↑(kz a)).snd	case mk.h.a.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ r (IContainer.N (C F) i nz a) (↑(kz a)).fst (↑(kz a)).snd
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	apply (kz a).2	case mk.h.a.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i✝ : I x✝ y✝ : M F i✝ h₁ : r i✝ x✝ y✝ i : I x y : M F i z : F (fun i => { p // r i p.fst p.snd }) i nz : IContainer.A (C F) i kz : (y : IContainer.B (C F) i nz) → (fun i => { p // r i p.fst p.snd }) (IContainer.N (C F) i nz y) a : IContainer.B (C F) i nz ⊢ r (IContainer.N (C F) i nz a) (↑(kz a)).fst (↑(kz a)).snd	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	right	case a I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ x = y ∨ r i x y	case a.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ r i x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/MIdx.lean	IQPF.M.bisim	[185, 1]	[216, 22]	assumption	case a.h I : Type u₁ F : (I → Type u₁) → I → Type u₁ inst : IQPF F r : (i : I) → M F i → M F i → Prop h₀ : ∀ (i : I) (x y : M F i), r i x y → liftr F r i (destruct x) (destruct y) i : I x y : M F i h₁ : r i x y ⊢ r i x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	intro h₀ x y h₁	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop ⊢ (∀ (x y : M (C F)), p x y → ↑(precongr F) p x y) → ∀ (x y : M (C F)), p x y → congr F x y	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y ⊢ congr F x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	simp only [congr, pcongr]	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y ⊢ congr F x y	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y ⊢ ↑(pgfp (precongr F)) ⊥ x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	have := (pgfp.coinduction (precongr F) p).2	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y ⊢ ↑(pgfp (precongr F)) ⊥ x y	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ ↑(pgfp (precongr F)) ⊥ x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	apply this	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ ↑(pgfp (precongr F)) ⊥ x y	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	have : p ≤ p ⊔ pgfp (precongr F) p := by simp	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this : p ≤ p ⊔ ↑(pgfp (precongr F)) p ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	have := (precongr F).2 this	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this : p ≤ p ⊔ ↑(pgfp (precongr F)) p ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝¹ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this✝ : p ≤ p ⊔ ↑(pgfp (precongr F)) p this : ↑(precongr F) p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	apply le_trans _ this	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝¹ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this✝ : p ≤ p ⊔ ↑(pgfp (precongr F)) p this : ↑(precongr F) p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) ⊢ p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝¹ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this✝ : p ≤ p ⊔ ↑(pgfp (precongr F)) p this : ↑(precongr F) p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) ⊢ p ≤ ↑(precongr F) p case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	apply h₀	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this✝¹ : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ this✝ : p ≤ p ⊔ ↑(pgfp (precongr F)) p this : ↑(precongr F) p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) ⊢ p ≤ ↑(precongr F) p case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	assumption	case a F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.congr.coinduction	[56, 1]	[67, 13]	simp	F✝ : Type u₁ → Type u₁ inst✝ : QPF F✝ F : Type u₁ → Type u₁ inst : QPF F p : M (C F) → M (C F) → Prop h₀ : ∀ (x y : M (C F)), p x y → ↑(precongr F) p x y x y : M (C F) h₁ : p x y this : p ≤ ↑(precongr F) (p ⊔ ↑(pgfp (precongr F)) p) → p ≤ ↑(pgfp (precongr F)) ⊥ ⊢ p ≤ p ⊔ ↑(pgfp (precongr F)) p	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.destruct_corec	[98, 1]	[105, 8]	simp only [destruct, corec, destruct.f, Container.M.destruct_corec, inst.abs_map, inst.abs_repr]	F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α ⊢ destruct (corec f x₀) = (fun x => corec f x) <$> f x₀	F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α ⊢ (fun x => Quot.mk (congr F) x) <$> (Container.M.corec fun x => repr (f x)) <$> f x₀ = (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) <$> f x₀
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.destruct_corec	[98, 1]	[105, 8]	rw [←inst.abs_repr (f x₀)]	F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α ⊢ (fun x => Quot.mk (congr F) x) <$> (Container.M.corec fun x => repr (f x)) <$> f x₀ = (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) <$> f x₀	F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α ⊢ (fun x => Quot.mk (congr F) x) <$> (Container.M.corec fun x => repr (f x)) <$> abs (repr (f x₀)) = (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) <$> abs (repr (f x₀))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.destruct_corec	[98, 1]	[105, 8]	cases repr (f x₀) with \| mk n k => simp only [←inst.abs_map, Container.Map] rfl	F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α ⊢ (fun x => Quot.mk (congr F) x) <$> (Container.M.corec fun x => repr (f x)) <$> abs (repr (f x₀)) = (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) <$> abs (repr (f x₀))	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.destruct_corec	[98, 1]	[105, 8]	simp only [←inst.abs_map, Container.Map]	case mk F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α n : (C F).A k : Container.B (C F) n → α ⊢ (fun x => Quot.mk (congr F) x) <$> (Container.M.corec fun x => repr (f x)) <$> abs { fst := n, snd := k } = (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) <$> abs { fst := n, snd := k }	case mk F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α n : (C F).A k : Container.B (C F) n → α ⊢ abs { fst := n, snd := (fun x => Quot.mk (congr F) x) ∘ (Container.M.corec fun x => repr (f x)) ∘ k } = abs { fst := n, snd := (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) ∘ k }
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.destruct_corec	[98, 1]	[105, 8]	rfl	case mk F : Type u₁ → Type u₁ inst : QPF F α : Type u₁ f : α → F α x₀ : α n : (C F).A k : Container.B (C F) n → α ⊢ abs { fst := n, snd := (fun x => Quot.mk (congr F) x) ∘ (Container.M.corec fun x => repr (f x)) ∘ k } = abs { fst := n, snd := (fun x => Quot.mk (congr F) (Container.M.corec (fun x => repr (f x)) x)) ∘ k }	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.map_comp	[119, 1]	[126, 6]	conv => congr <;> rw [←inst.abs_repr x]	F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α ⊢ (f ∘ g) <$> x = f <$> g <$> x	F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α ⊢ (f ∘ g) <$> abs (repr x) = f <$> g <$> abs (repr x)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.map_comp	[119, 1]	[126, 6]	cases repr x	F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α ⊢ (f ∘ g) <$> abs (repr x) = f <$> g <$> abs (repr x)	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α fst✝ : (C F).A snd✝ : Container.B (C F) fst✝ → α ⊢ (f ∘ g) <$> abs { fst := fst✝, snd := snd✝ } = f <$> g <$> abs { fst := fst✝, snd := snd✝ }
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.map_comp	[119, 1]	[126, 6]	simp [←inst.abs_map, Container.Map]	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α fst✝ : (C F).A snd✝ : Container.B (C F) fst✝ → α ⊢ (f ∘ g) <$> abs { fst := fst✝, snd := snd✝ } = f <$> g <$> abs { fst := fst✝, snd := snd✝ }	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α fst✝ : (C F).A snd✝ : Container.B (C F) fst✝ → α ⊢ abs { fst := fst✝, snd := (f ∘ g) ∘ snd✝ } = abs { fst := fst✝, snd := f ∘ g ∘ snd✝ }
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.map_comp	[119, 1]	[126, 6]	rfl	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : F α fst✝ : (C F).A snd✝ : Container.B (C F) fst✝ → α ⊢ abs { fst := fst✝, snd := (f ∘ g) ∘ snd✝ } = abs { fst := fst✝, snd := f ∘ g ∘ snd✝ }	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	Container.Map_spec	[129, 1]	[133, 6]	cases x	F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β x : Obj (QPF.C F) α ⊢ Map (f ∘ g) x = Map f (Map g x)	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β fst✝ : (QPF.C F).A snd✝ : B (QPF.C F) fst✝ → α ⊢ Map (f ∘ g) { fst := fst✝, snd := snd✝ } = Map f (Map g { fst := fst✝, snd := snd✝ })
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	Container.Map_spec	[129, 1]	[133, 6]	simp [Map]	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β fst✝ : (QPF.C F).A snd✝ : B (QPF.C F) fst✝ → α ⊢ Map (f ∘ g) { fst := fst✝, snd := snd✝ } = Map f (Map g { fst := fst✝, snd := snd✝ })	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β fst✝ : (QPF.C F).A snd✝ : B (QPF.C F) fst✝ → α ⊢ (f ∘ g) ∘ snd✝ = f ∘ g ∘ snd✝
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	Container.Map_spec	[129, 1]	[133, 6]	rfl	case mk F : Type u₁ → Type u₁ inst : QPF F α β γ : Type u₁ f : β → γ g : α → β fst✝ : (QPF.C F).A snd✝ : B (QPF.C F) fst✝ → α ⊢ (f ∘ g) ∘ snd✝ = f ∘ g ∘ snd✝	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 : M F), r x y → 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 : M F ⊢ ∀ (y : M F), r x y → x = y
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 : M F ⊢ ∀ (y : M F), r x y → 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 : M F ⊢ ∀ (a : Container.M (C F)) (y : M F), r (Quot.mk (congr F) a) y → Quot.mk (congr F) a = y
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 : M F ⊢ ∀ (a : Container.M (C F)) (y : M F), r (Quot.mk (congr F) a) y → Quot.mk (congr F) a = 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 ⊢ ∀ (a : Container.M (C F)) (y : M F), r (Quot.mk (congr F) a) y → Quot.mk (congr F) a = y
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 ⊢ ∀ (a : Container.M (C F)) (y : M F), r (Quot.mk (congr F) a) y → Quot.mk (congr F) a = 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 : Container.M (C F) y : M F ⊢ r (Quot.mk (congr F) x) y → Quot.mk (congr F) x = 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 : Container.M (C F) y : M F ⊢ r (Quot.mk (congr F) x) y → Quot.mk (congr F) 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 : Container.M (C F) y : M F ⊢ ∀ (a : Container.M (C F)), r (Quot.mk (congr F) x) (Quot.mk (congr F) a) → Quot.mk (congr F) x = 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 : Container.M (C F) y : M F ⊢ ∀ (a : Container.M (C F)), r (Quot.mk (congr F) x) (Quot.mk (congr F) a) → Quot.mk (congr F) x = 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 : Container.M (C F) ⊢ ∀ (a : Container.M (C F)), r (Quot.mk (congr F) x) (Quot.mk (congr F) a) → Quot.mk (congr F) x = 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 : Container.M (C F) ⊢ ∀ (a : Container.M (C F)), r (Quot.mk (congr F) x) (Quot.mk (congr F) a) → Quot.mk (congr F) x = 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) h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y) ⊢ Quot.mk (congr F) x = 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) h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y) ⊢ Quot.mk (congr F) x = 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) h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y) ⊢ congr F x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/M.lean	QPF.M.bisim_lemma	[135, 1]	[187, 13]	let r' x y := r (Quot.mk _ x) (Quot.mk _ 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) h₂ : r (Quot.mk (congr F) x) (Quot.mk (congr F) y) ⊢ congr F x 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) 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

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.