internlm/Lean-Github · Datasets at Hugging Face

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/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	. simp only [←QPF.map_comp, Function.comp] rfl	case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).snd) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) x) <$> Sum.inr <$> QPF.M.destruct x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	rfl	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x✝ y x : QPF.M (FreeF F S) ⊢ (fun x y => QPF.M.corec (bind.automaton k) (Sum.inr x) = y) (x, corec (bind.automaton k) (Sum.inr x)).fst (x, corec (bind.automaton k) (Sum.inr x)).snd	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	simp only [←QPF.map_comp, Function.comp]	case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = QPF.M.destruct x	case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = QPF.M.destruct x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	apply Eq.trans _ (QPF.map_id _)	case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = QPF.M.destruct x	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = id <$> QPF.M.destruct x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	rfl	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = id <$> QPF.M.destruct x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	simp only [←QPF.map_comp, Function.comp]	case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).snd) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) x) <$> Sum.inr <$> QPF.M.destruct x	case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr.internal	[186, 1]	[205, 10]	rfl	case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr	[207, 1]	[212, 14]	intro x	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S ⊢ ∀ (x : Free F S), corec (bind.automaton k) (Sum.inr x) = x	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr	[207, 1]	[212, 14]	have := Free.bind_inr.internal k x (corec (bind.automaton k) (.inr x)) (by rfl)	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = x	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S this : x = corec (bind.automaton k) (Sum.inr x) ⊢ corec (bind.automaton k) (Sum.inr x) = x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr	[207, 1]	[212, 14]	conv => rhs rw [this]	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S this : x = corec (bind.automaton k) (Sum.inr x) ⊢ corec (bind.automaton k) (Sum.inr x) = x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_inr	[207, 1]	[212, 14]	rfl	F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = corec (bind.automaton k) (Sum.inr x)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	simp only [pure, bind]	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ pure x >>= k = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Pure x))) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	conv => lhs rw [←construct_destruct (corec (bind.automaton k) (.inl (construct <\| .Pure x)))] rw [destruct_corec] rhs rhs simp only [bind.automaton, destruct_construct]	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Pure x))) = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> Sum.inr <$> destruct (k x)) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	simp only [←QPF.map_comp, Function.comp]	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> Sum.inr <$> destruct (k x)) = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => corec (bind.automaton k) (Sum.inr x)) <$> destruct (k x)) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	conv => lhs congr lhs intro x rw [bind_inr]	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => corec (bind.automaton k) (Sum.inr x)) <$> destruct (k x)) = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => x) <$> destruct (k x)) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	have := QPF.map_id (destruct (k x))	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => x) <$> destruct (k x)) = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : id <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	simp only [id] at this	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : id <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : (fun a => a) <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.pure_bind	[214, 9]	[232, 32]	rw [this, construct_destruct]	F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : (fun a => a) <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.free_bind	[235, 9]	[245, 56]	simp only [free, bind, flip]	F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ free f >>= k = free (flip bind k <$> f)	F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Free f))) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.free_bind	[235, 9]	[245, 56]	conv => lhs rw [←construct_destruct (corec (bind.automaton k) (.inl (construct <\| .Free f)))] rw [destruct_corec] rhs rhs simp only [bind.automaton, destruct_construct]	F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Free f))) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))	F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f)) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.free_bind	[235, 9]	[245, 56]	apply congrArg	F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f)) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))	case h F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f) = FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.free_bind	[235, 9]	[245, 56]	simp only [Functor.map, ←QPF.map_comp, Function.comp]	case h F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f) = FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	apply QPF.M.bisim	F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : Free F R), x >>= pure = y → x = y	case h₀ F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : QPF.M (FreeF F R)), x >>= pure = y → QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	intro x y h₁	case h₀ F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : QPF.M (FreeF F R)), x >>= pure = y → QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)	case h₀ F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) h₁ : x >>= pure = y ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	induction h₁	case h₀ F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) h₁ : x >>= pure = y ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)	case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct (x >>= pure))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	exists (λ x => ⟨(x, bind x Free.Monad.pure), by rfl⟩) <$> destruct x	case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct (x >>= pure))	case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct x ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct (x >>= pure)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	cases x using by_cases with \| pure r => have : destruct (pure r) = .Pure r := by exact @destruct_construct F _ R (FreeF.Pure r) simp only [Functor.map, this, pure_bind r] constructor <;> rfl \| free f => have : destruct (free f) = .Free f := by exact @destruct_construct F _ R (FreeF.Free f) simp only [Functor.map, this, free_bind, ←QPF.map_comp, Function.comp] constructor . conv => rhs congr rw [←QPF.map_id f] rw [free, construct, QPF.M.destruct_construct] rfl . simp only [free, construct, QPF.M.destruct_construct] rfl	case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct x ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct (x >>= pure)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	rfl	F : Type u → Type u inst : QPF F R : Type u x✝ y x : QPF.M (FreeF F R) ⊢ (fun x y => x >>= pure = y) (x, x >>= pure).fst (x, x >>= pure).snd	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	have : destruct (pure r) = .Pure r := by exact @destruct_construct F _ R (FreeF.Pure r)	case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)	case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	simp only [Functor.map, this, pure_bind r]	case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)	case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ FreeF.Pure r = QPF.M.destruct (pure r) ∧ FreeF.Pure r = QPF.M.destruct (pure r)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	constructor <;> rfl	case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ FreeF.Pure r = QPF.M.destruct (pure r) ∧ FreeF.Pure r = QPF.M.destruct (pure r)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	exact @destruct_construct F _ R (FreeF.Pure r)	F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R ⊢ destruct (pure r) = FreeF.Pure r	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	have : destruct (free f) = .Free f := by exact @destruct_construct F _ R (FreeF.Free f)	case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)	case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	simp only [Functor.map, this, free_bind, ←QPF.map_comp, Function.comp]	case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)	case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) ∧ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	constructor	case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) ∧ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	. conv => rhs congr rw [←QPF.map_id f] rw [free, construct, QPF.M.destruct_construct] rfl	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))	case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	. simp only [free, construct, QPF.M.destruct_construct] rfl	case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	exact @destruct_construct F _ R (FreeF.Free f)	F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) ⊢ destruct (free f) = FreeF.Free f	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	conv => rhs congr rw [←QPF.map_id f]	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f)	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free (id <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	rw [free, construct, QPF.M.destruct_construct]	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free (id <$> f))	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = FreeF.Free (id <$> f)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	rfl	case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = FreeF.Free (id <$> f)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	simp only [free, construct, QPF.M.destruct_construct]	case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))	case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = FreeF.Free (flip bind pure <$> f)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure.internal	[247, 1]	[270, 10]	rfl	case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = FreeF.Free (flip bind pure <$> f)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_pure	[272, 9]	[277, 8]	conv => rhs rw [bind_pure.internal x (bind x pure)] rfl rfl	F : Type u → Type u inst : QPF F R : Type u x : Free F R ⊢ x >>= pure = x	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	simp only [Free.eq, Free.eqP, pgfp.coinduction]	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eq	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	intro y z ⟨x, h₁, h₂⟩	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z)	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₁ : x >>= k₁ >>= k₂ = y h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) y z
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	induction h₁	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₁ : x >>= k₁ >>= k₂ = y h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) y z	case refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) z
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	induction h₂	case refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) z	case refl.refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) (x >>= flip bind k₂ ∘ k₁)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	cases x using by_cases with \| pure r => simp only [pure_bind, flip, Function.comp] apply @eqF.monotone F inst T eq . intro x y h apply Or.inr apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥ . intro x y h cases h . exact h . have := eq.refl (k₁ r >>= k₂) rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this exact this \| free f => simp only [←QPF.map_comp, free_bind] let P : Free F T → Free F T → Prop :=(λ y z:Free F T => ∃ x, (x >>= k₁ >>= k₂) = y ∧ x >>= (flip bind k₂ ∘ k₁) = z) apply @eqF.monotone F inst T P . intro x y h apply Or.inl exact h . apply eqF.Free exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f simp only [←QPF.map_comp] constructor . constructor . constructor	case refl.refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) (x >>= flip bind k₂ ∘ k₁)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	simp only [pure_bind, flip, Function.comp]	case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (pure r >>= k₁ >>= k₂) (pure r >>= flip bind k₂ ∘ k₁)	case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) (k₁ r >>= k₂) (k₁ r >>= k₂)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply @eqF.monotone F inst T eq	case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) (k₁ r >>= k₂) (k₁ r >>= k₂)	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. intro x y h apply Or.inr apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥ . intro x y h cases h . exact h	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. have := eq.refl (k₁ r >>= k₂) rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this exact this	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	intro x y h	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply Or.inr	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y	case refl.refl.pure.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥	case refl.refl.pure.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. intro x y h cases h	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. exact h	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	intro x y h	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝¹ z : Free F T r : R x✝ y✝ : Free F T h✝ : eq x✝ y✝ x y : Free F T h : ⊥ x y ⊢ ∃ x_1, x_1 >>= k₁ >>= k₂ = x ∧ (x_1 >>= fun x => k₁ x >>= k₂) = y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	cases h	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝¹ z : Free F T r : R x✝ y✝ : Free F T h✝ : eq x✝ y✝ x y : Free F T h : ⊥ x y ⊢ ∃ x_1, x_1 >>= k₁ >>= k₂ = x ∧ (x_1 >>= fun x => k₁ x >>= k₂) = y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	exact h	case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	have := eq.refl (k₁ r >>= k₂)	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : eq (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : eq (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : ↑{ toFun := eqF, monotone' := (_ : Monotone eqF) } (↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥) (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	exact this	case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : ↑{ toFun := eqF, monotone' := (_ : Monotone eqF) } (↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥) (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	simp only [←QPF.map_comp, free_bind]	case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free f >>= k₁ >>= k₂) (free f >>= flip bind k₂ ∘ k₁)	case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	let P : Free F T → Free F T → Prop :=(λ y z:Free F T => ∃ x, (x >>= k₁ >>= k₂) = y ∧ x >>= (flip bind k₂ ∘ k₁) = z)	case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))	case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply @eqF.monotone F inst T P	case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. intro x y h apply Or.inl exact h	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. apply eqF.Free exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f simp only [←QPF.map_comp] constructor . constructor . constructor	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	intro x y h	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply Or.inl	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y	case refl.refl.free.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	exact h	case refl.refl.free.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	apply eqF.Free	case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ QPF.M.liftr F P ((flip bind k₂ ∘ flip bind k₁) <$> f) (flip bind (flip bind k₂ ∘ k₁) <$> f)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ QPF.M.liftr F P ((flip bind k₂ ∘ flip bind k₁) <$> f) (flip bind (flip bind k₂ ∘ k₁) <$> f)	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	simp only [←QPF.map_comp]	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	constructor	case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f	case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. constructor	case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f	case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	. constructor	case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	exists x	F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x : Free F R ⊢ P (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	constructor	case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind.internal	[283, 1]	[314, 20]	constructor	case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind	[316, 1]	[322, 11]	have h₁ := bind_bind.internal k₁ k₂ (t >>= k₁ >>= k₂) (t >>= (flip bind k₂ ∘ k₁))	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind	[316, 1]	[322, 11]	have h₂ := Free.eq.bisim (t >>= k₁ >>= k₂) (t >>= (flip bind k₂ ∘ k₁))	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind	[316, 1]	[322, 11]	apply h₂	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind	[316, 1]	[322, 11]	apply h₁	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁)	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ ∃ x, x >>= k₁ >>= k₂ = t >>= k₁ >>= k₂ ∧ x >>= flip bind k₂ ∘ k₁ = t >>= flip bind k₂ ∘ k₁
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/QPF/FreeMonads.lean	Free.bind_bind	[316, 1]	[322, 11]	exists t	F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ ∃ x, x >>= k₁ >>= k₂ = t >>= k₁ >>= k₂ ∧ x >>= flip bind k₂ ∘ k₁ = t >>= flip bind k₂ ∘ k₁	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.equiv.coinduction	[129, 1]	[134, 11]	intro h x y h'	C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop ⊢ (∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y) → ∀ (x : Free C R) (y : Free C S), P x y → equiv eq x y	C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ equiv eq x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.equiv.coinduction	[129, 1]	[134, 11]	apply (pgfp.coinduction (equivF' eq) P).2	C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ equiv eq x y	case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P ≤ ↑(equivF' eq) (P ⊔ ↑(pgfp (equivF' eq)) P) case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.equiv.coinduction	[129, 1]	[134, 11]	apply h	case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P ≤ ↑(equivF' eq) (P ⊔ ↑(pgfp (equivF' eq)) P) case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y	case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.equiv.coinduction	[129, 1]	[134, 11]	apply h'	case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	apply M.bisim	C : _root_.Container R : Type u₁ ⊢ ∀ (x y : Free C R), eq x y → x = y	case h₀ C : _root_.Container R : Type u₁ ⊢ ∀ (x y : M (Container C R)), eq x y → ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	intro x y h₁	case h₀ C : _root_.Container R : Type u₁ ⊢ ∀ (x y : M (Container C R)), eq x y → ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : eq x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	simp [eq, equiv, pequiv] at h₁	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : eq x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(pgfp (equivF' Eq)) ⊥ x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	rw [←pgfp.unfold] at h₁	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(pgfp (equivF' Eq)) ⊥ x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(equivF' Eq) (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	cases h₁ with \| Pure x y h₁ => induction h₁ exists (A.Pure x) exists (λ e => e.casesOn) exists (λ e => e.casesOn) simp only [construct, M.destruct_construct, inv, true_and] intro x apply x.elim \| Free node k₁ k₂ h => exists (A.Free node) exists k₁ exists k₂ simp only [construct, M.destruct_construct, inv, true_and] intro x rw [CompleteLattice.bot_sup] at h apply h	case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(equivF' Eq) (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	no goals
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	induction h₁	case h₀.Pure C : _root_.Container R : Type u₁ x y : R h₁ : x = y ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure y)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	exists (A.Pure x)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (k₁ i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	exists (λ e => e.casesOn)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (k₁ i) (k₂ i)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) (k₂ i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	exists (λ e => e.casesOn)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) (k₂ i)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i)
https://github.com/RemyCiterin/LeanCoInd.git	69d305ae769624f460f9c1ee6a0351917f4b74cf	CoInd/FreeMonads.lean	Free.eq.bisim	[136, 1]	[158, 12]	simp only [construct, M.destruct_construct, inv, true_and]	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i)	case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (PEmpty.rec (fun x => M (Container C R)) i) (PEmpty.rec (fun x => M (Container C R)) i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

. simp only [←QPF.map_comp, Function.comp] rfl

case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).snd) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) x) <$> Sum.inr <$> QPF.M.destruct x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

rfl

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x✝ y x : QPF.M (FreeF F S) ⊢ (fun x y => QPF.M.corec (bind.automaton k) (Sum.inr x) = y) (x, corec (bind.automaton k) (Sum.inr x)).fst (x, corec (bind.automaton k) (Sum.inr x)).snd

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

simp only [←QPF.map_comp, Function.comp]

case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = QPF.M.destruct x

case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = QPF.M.destruct x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

apply Eq.trans _ (QPF.map_id _)

case refl.left F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = QPF.M.destruct x

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = id <$> QPF.M.destruct x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

rfl

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => x) <$> QPF.M.destruct x = id <$> QPF.M.destruct x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

simp only [←QPF.map_comp, Function.comp]

case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => (↑x).snd) <$> (fun x => { val := (x, corec (bind.automaton k) (Sum.inr x)), property := (_ : QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst) = QPF.M.corec (bind.automaton k) (Sum.inr (x, corec (bind.automaton k) (Sum.inr x)).fst)) }) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) x) <$> Sum.inr <$> QPF.M.destruct x

case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr.internal

[186, 1]

[205, 10]

rfl

case refl.right F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x y : QPF.M (FreeF F S) ⊢ (fun x => corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x = (fun x => QPF.M.corec (bind.automaton k) (Sum.inr x)) <$> QPF.M.destruct x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr

[207, 1]

[212, 14]

intro x

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S ⊢ ∀ (x : Free F S), corec (bind.automaton k) (Sum.inr x) = x

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr

[207, 1]

[212, 14]

have := Free.bind_inr.internal k x (corec (bind.automaton k) (.inr x)) (by rfl)

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = x

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S this : x = corec (bind.automaton k) (Sum.inr x) ⊢ corec (bind.automaton k) (Sum.inr x) = x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr

[207, 1]

[212, 14]

conv => rhs rw [this]

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S this : x = corec (bind.automaton k) (Sum.inr x) ⊢ corec (bind.automaton k) (Sum.inr x) = x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_inr

[207, 1]

[212, 14]

rfl

F : Type u → Type u inst : QPF F R S : Type u k : R → Free F S x : Free F S ⊢ corec (bind.automaton k) (Sum.inr x) = corec (bind.automaton k) (Sum.inr x)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

simp only [pure, bind]

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ pure x >>= k = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Pure x))) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

conv => lhs rw [←construct_destruct (corec (bind.automaton k) (.inl (construct <| .Pure x)))] rw [destruct_corec] rhs rhs simp only [bind.automaton, destruct_construct]

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Pure x))) = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> Sum.inr <$> destruct (k x)) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

simp only [←QPF.map_comp, Function.comp]

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> Sum.inr <$> destruct (k x)) = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => corec (bind.automaton k) (Sum.inr x)) <$> destruct (k x)) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

conv => lhs congr lhs intro x rw [bind_inr]

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => corec (bind.automaton k) (Sum.inr x)) <$> destruct (k x)) = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

have := QPF.map_id (destruct (k x))

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : id <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

simp only [id] at this

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : id <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : (fun a => a) <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.pure_bind

[214, 9]

[232, 32]

rw [this, construct_destruct]

F : Type u → Type u inst : QPF F R S : Type u x : R k : R → Free F S this : (fun a => a) <$> destruct (k x) = destruct (k x) ⊢ construct ((fun x => x) <$> destruct (k x)) = k x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.free_bind

[235, 9]

[245, 56]

simp only [free, bind, flip]

F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ free f >>= k = free (flip bind k <$> f)

F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Free f))) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.free_bind

[235, 9]

[245, 56]

conv => lhs rw [←construct_destruct (corec (bind.automaton k) (.inl (construct <| .Free f)))] rw [destruct_corec] rhs rhs simp only [bind.automaton, destruct_construct]

F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) (Sum.inl (construct (FreeF.Free f))) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))

F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f)) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.free_bind

[235, 9]

[245, 56]

apply congrArg

F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ construct (corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f)) = construct (FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f))

case h F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f) = FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.free_bind

[235, 9]

[245, 56]

simp only [Functor.map, ←QPF.map_comp, Function.comp]

case h F : Type u → Type u inst : QPF F R S : Type u f : F (Free F R) k : R → Free F S ⊢ corec (bind.automaton k) <$> FreeF.Free (Sum.inl <$> f) = FreeF.Free ((fun a => corec (bind.automaton k) (Sum.inl a)) <$> f)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

apply QPF.M.bisim

F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : Free F R), x >>= pure = y → x = y

case h₀ F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : QPF.M (FreeF F R)), x >>= pure = y → QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

intro x y h₁

case h₀ F : Type u → Type u inst : QPF F R : Type u ⊢ ∀ (x y : QPF.M (FreeF F R)), x >>= pure = y → QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)

case h₀ F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) h₁ : x >>= pure = y ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

induction h₁

case h₀ F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) h₁ : x >>= pure = y ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct y)

case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct (x >>= pure))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

exists (λ x => ⟨(x, bind x Free.Monad.pure), by rfl⟩) <$> destruct x

case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ QPF.M.liftr (FreeF F R) (fun x y => x >>= pure = y) (QPF.M.destruct x) (QPF.M.destruct (x >>= pure))

case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct x ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct (x >>= pure)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

cases x using by_cases with | pure r => have : destruct (pure r) = .Pure r := by exact @destruct_construct F _ R (FreeF.Pure r) simp only [Functor.map, this, pure_bind r] constructor <;> rfl | free f => have : destruct (free f) = .Free f := by exact @destruct_construct F _ R (FreeF.Free f) simp only [Functor.map, this, free_bind, ←QPF.map_comp, Function.comp] constructor . conv => rhs congr rw [←QPF.map_id f] rw [free, construct, QPF.M.destruct_construct] rfl . simp only [free, construct, QPF.M.destruct_construct] rfl

case h₀.refl F : Type u → Type u inst : QPF F R : Type u x y : QPF.M (FreeF F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct x ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct x = QPF.M.destruct (x >>= pure)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

rfl

F : Type u → Type u inst : QPF F R : Type u x✝ y x : QPF.M (FreeF F R) ⊢ (fun x y => x >>= pure = y) (x, x >>= pure).fst (x, x >>= pure).snd

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

have : destruct (pure r) = .Pure r := by exact @destruct_construct F _ R (FreeF.Pure r)

case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)

case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

simp only [Functor.map, this, pure_bind r]

case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (pure r) = QPF.M.destruct (pure r >>= pure)

case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ FreeF.Pure r = QPF.M.destruct (pure r) ∧ FreeF.Pure r = QPF.M.destruct (pure r)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

constructor <;> rfl

case h₀.refl.pure F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R this : destruct (pure r) = FreeF.Pure r ⊢ FreeF.Pure r = QPF.M.destruct (pure r) ∧ FreeF.Pure r = QPF.M.destruct (pure r)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

exact @destruct_construct F _ R (FreeF.Pure r)

F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) r : R ⊢ destruct (pure r) = FreeF.Pure r

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

have : destruct (free f) = .Free f := by exact @destruct_construct F _ R (FreeF.Free f)

case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)

case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

simp only [Functor.map, this, free_bind, ←QPF.map_comp, Function.comp]

case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f) ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x, x >>= pure), property := (_ : (x, x >>= pure).fst >>= pure = (x, x >>= pure).fst >>= pure) }) <$> destruct (free f) = QPF.M.destruct (free f >>= pure)

case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) ∧ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

constructor

case h₀.refl.free F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) ∧ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

. conv => rhs congr rw [←QPF.map_id f] rw [free, construct, QPF.M.destruct_construct] rfl

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f) case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

. simp only [free, construct, QPF.M.destruct_construct] rfl

case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

exact @destruct_construct F _ R (FreeF.Free f)

F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) ⊢ destruct (free f) = FreeF.Free f

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

conv => rhs congr rw [←QPF.map_id f]

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free f)

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free (id <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

rw [free, construct, QPF.M.destruct_construct]

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = QPF.M.destruct (free (id <$> f))

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = FreeF.Free (id <$> f)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

rfl

case h₀.refl.free.left F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x) <$> f) = FreeF.Free (id <$> f)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

simp only [free, construct, QPF.M.destruct_construct]

case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = QPF.M.destruct (free (flip bind pure <$> f))

case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = FreeF.Free (flip bind pure <$> f)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure.internal

[247, 1]

[270, 10]

rfl

case h₀.refl.free.right F : Type u → Type u inst : QPF F R : Type u y : QPF.M (FreeF F R) f : F (Free F R) this : destruct (free f) = FreeF.Free f ⊢ FreeF.Free ((fun x => x >>= pure) <$> f) = FreeF.Free (flip bind pure <$> f)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_pure

[272, 9]

[277, 8]

conv => rhs rw [bind_pure.internal x (bind x pure)] rfl rfl

F : Type u → Type u inst : QPF F R : Type u x : Free F R ⊢ x >>= pure = x

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

simp only [Free.eq, Free.eqP, pgfp.coinduction]

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eq

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

intro y z ⟨x, h₁, h₂⟩

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ≤ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z)

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₁ : x >>= k₁ >>= k₂ = y h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) y z

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

induction h₁

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₁ : x >>= k₁ >>= k₂ = y h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) y z

case refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) z

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

induction h₂

case refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R h₂ : x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) z

case refl.refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) (x >>= flip bind k₂ ∘ k₁)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

cases x using by_cases with | pure r => simp only [pure_bind, flip, Function.comp] apply @eqF.monotone F inst T eq . intro x y h apply Or.inr apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥ . intro x y h cases h . exact h . have := eq.refl (k₁ r >>= k₂) rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this exact this | free f => simp only [←QPF.map_comp, free_bind] let P : Free F T → Free F T → Prop :=(λ y z:Free F T => ∃ x, (x >>= k₁ >>= k₂) = y ∧ x >>= (flip bind k₂ ∘ k₁) = z) apply @eqF.monotone F inst T P . intro x y h apply Or.inl exact h . apply eqF.Free exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f simp only [←QPF.map_comp] constructor . constructor . constructor

case refl.refl F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T x : Free F R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (x >>= k₁ >>= k₂) (x >>= flip bind k₂ ∘ k₁)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

simp only [pure_bind, flip, Function.comp]

case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (pure r >>= k₁ >>= k₂) (pure r >>= flip bind k₂ ∘ k₁)

case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) (k₁ r >>= k₂) (k₁ r >>= k₂)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply @eqF.monotone F inst T eq

case refl.refl.pure F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) (k₁ r >>= k₂) (k₁ r >>= k₂)

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. intro x y h apply Or.inr apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥ . intro x y h cases h . exact h

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. have := eq.refl (k₁ r >>= k₂) rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this exact this

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

intro x y h

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eq ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply Or.inr

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y

case refl.refl.pure.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply pgfp.monotone ⟨eqF, eqF.monotone⟩ ⊥

case refl.refl.pure.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z) x y

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. intro x y h cases h

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. exact h

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

intro x y h

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ⊥ ≤ fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ (x >>= fun x => k₁ x >>= k₂) = z

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝¹ z : Free F T r : R x✝ y✝ : Free F T h✝ : eq x✝ y✝ x y : Free F T h : ⊥ x y ⊢ ∃ x_1, x_1 >>= k₁ >>= k₂ = x ∧ (x_1 >>= fun x => k₁ x >>= k₂) = y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

cases h

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝¹ z : Free F T r : R x✝ y✝ : Free F T h✝ : eq x✝ y✝ x y : Free F T h : ⊥ x y ⊢ ∃ x_1, x_1 >>= k₁ >>= k₂ = x ∧ (x_1 >>= fun x => k₁ x >>= k₂) = y

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

exact h

case refl.refl.pure.a.h.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T r : R x y : Free F T h : eq x y ⊢ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥ x y

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

have := eq.refl (k₁ r >>= k₂)

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : eq (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

rw [eq, eqP, ←pgfp.unfold, CompleteLattice.bot_sup] at this

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : eq (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : ↑{ toFun := eqF, monotone' := (_ : Monotone eqF) } (↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥) (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

exact this

case refl.refl.pure.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T r : R this : ↑{ toFun := eqF, monotone' := (_ : Monotone eqF) } (↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) ⊥) (k₁ r >>= k₂) (k₁ r >>= k₂) ⊢ eqF eq (k₁ r >>= k₂) (k₁ r >>= k₂)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

simp only [←QPF.map_comp, free_bind]

case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free f >>= k₁ >>= k₂) (free f >>= flip bind k₂ ∘ k₁)

case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

let P : Free F T → Free F T → Prop :=(λ y z:Free F T => ∃ x, (x >>= k₁ >>= k₂) = y ∧ x >>= (flip bind k₂ ∘ k₁) = z)

case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply @eqF.monotone F inst T P

case refl.refl.free F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. intro x y h apply Or.inl exact h

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. apply eqF.Free exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f simp only [←QPF.map_comp] constructor . constructor . constructor

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

intro x y h

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ P ≤ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply Or.inl

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ ((fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) ⊔ ↑(pgfp { toFun := eqF, monotone' := (_ : Monotone eqF) }) fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y

case refl.refl.free.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

exact h

case refl.refl.free.a.h F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y✝ z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x y : Free F T h : P x y ⊢ (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) x y

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

apply eqF.Free

case refl.refl.free.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ eqF P (free ((flip bind k₂ ∘ flip bind k₁) <$> f)) (free (flip bind (flip bind k₂ ∘ k₁) <$> f))

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ QPF.M.liftr F P ((flip bind k₂ ∘ flip bind k₁) <$> f) (flip bind (flip bind k₂ ∘ k₁) <$> f)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

exists inst.map (λ x => ⟨⟨x >>= k₁ >>= k₂, x >>= (flip bind k₂ ∘ k₁)⟩, by exists x⟩) f

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ QPF.M.liftr F P ((flip bind k₂ ∘ flip bind k₁) <$> f) (flip bind (flip bind k₂ ∘ k₁) <$> f)

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

simp only [←QPF.map_comp]

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ (fun x => (↑x).fst) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ (fun x => (↑x).snd) <$> (fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

constructor

case refl.refl.free.a.a F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f ∧ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. constructor

case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

. constructor

case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

exists x

F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z x : Free F R ⊢ P (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

constructor

case refl.refl.free.a.a.left F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).fst) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = (flip bind k₂ ∘ flip bind k₁) <$> f

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind.internal

[283, 1]

[314, 20]

constructor

case refl.refl.free.a.a.right F : Type u → Type u inst : QPF F R S T : Type u k₁ : R → Free F S k₂ : S → Free F T y z : Free F T f : F (Free F R) P : Free F T → Free F T → Prop := fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z ⊢ ((fun x => (↑x).snd) ∘ fun x => { val := (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁), property := (_ : ∃ x_1, x_1 >>= k₁ >>= k₂ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).fst ∧ x_1 >>= flip bind k₂ ∘ k₁ = (x >>= k₁ >>= k₂, x >>= flip bind k₂ ∘ k₁).snd) }) <$> f = flip bind (flip bind k₂ ∘ k₁) <$> f

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind

[316, 1]

[322, 11]

have h₁ := bind_bind.internal k₁ k₂ (t >>= k₁ >>= k₂) (t >>= (flip bind k₂ ∘ k₁))

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind

[316, 1]

[322, 11]

have h₂ := Free.eq.bisim (t >>= k₁ >>= k₂) (t >>= (flip bind k₂ ∘ k₁))

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind

[316, 1]

[322, 11]

apply h₂

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind

[316, 1]

[322, 11]

apply h₁

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁)

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ ∃ x, x >>= k₁ >>= k₂ = t >>= k₁ >>= k₂ ∧ x >>= flip bind k₂ ∘ k₁ = t >>= flip bind k₂ ∘ k₁

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/QPF/FreeMonads.lean

Free.bind_bind

[316, 1]

[322, 11]

exists t

F : Type u → Type u inst : QPF F R S T : Type u t : Free F R k₁ : R → Free F S k₂ : S → Free F T h₁ : (fun y z => ∃ x, x >>= k₁ >>= k₂ = y ∧ x >>= flip bind k₂ ∘ k₁ = z) (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) ≤ eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) h₂ : eq (t >>= k₁ >>= k₂) (t >>= flip bind k₂ ∘ k₁) → t >>= k₁ >>= k₂ = t >>= flip bind k₂ ∘ k₁ ⊢ ∃ x, x >>= k₁ >>= k₂ = t >>= k₁ >>= k₂ ∧ x >>= flip bind k₂ ∘ k₁ = t >>= flip bind k₂ ∘ k₁

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.equiv.coinduction

[129, 1]

[134, 11]

intro h x y h'

C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop ⊢ (∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y) → ∀ (x : Free C R) (y : Free C S), P x y → equiv eq x y

C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ equiv eq x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.equiv.coinduction

[129, 1]

[134, 11]

apply (pgfp.coinduction (equivF' eq) P).2

C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ equiv eq x y

case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P ≤ ↑(equivF' eq) (P ⊔ ↑(pgfp (equivF' eq)) P) case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.equiv.coinduction

[129, 1]

[134, 11]

apply h

case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P ≤ ↑(equivF' eq) (P ⊔ ↑(pgfp (equivF' eq)) P) case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y

case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.equiv.coinduction

[129, 1]

[134, 11]

apply h'

case a C : _root_.Container R S : Type u₁ eq : R → S → Prop P : Free C R → Free C S → Prop h : ∀ (x : Free C R) (y : Free C S), P x y → equivF eq (P ⊔ pequiv eq P) x y x : Free C R y : Free C S h' : P x y ⊢ P x y

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

apply M.bisim

C : _root_.Container R : Type u₁ ⊢ ∀ (x y : Free C R), eq x y → x = y

case h₀ C : _root_.Container R : Type u₁ ⊢ ∀ (x y : M (Container C R)), eq x y → ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

intro x y h₁

case h₀ C : _root_.Container R : Type u₁ ⊢ ∀ (x y : M (Container C R)), eq x y → ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : eq x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

simp [eq, equiv, pequiv] at h₁

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : eq x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(pgfp (equivF' Eq)) ⊥ x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

rw [←pgfp.unfold] at h₁

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(pgfp (equivF' Eq)) ⊥ x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(equivF' Eq) (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

cases h₁ with | Pure x y h₁ => induction h₁ exists (A.Pure x) exists (λ e => e.casesOn) exists (λ e => e.casesOn) simp only [construct, M.destruct_construct, inv, true_and] intro x apply x.elim | Free node k₁ k₂ h => exists (A.Free node) exists k₁ exists k₂ simp only [construct, M.destruct_construct, inv, true_and] intro x rw [CompleteLattice.bot_sup] at h apply h

case h₀ C : _root_.Container R : Type u₁ x y : M (Container C R) h₁ : ↑(equivF' Eq) (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) x y ⊢ ∃ node k₁ k₂, M.destruct x = { fst := node, snd := k₁ } ∧ M.destruct y = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

no goals

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

induction h₁

case h₀.Pure C : _root_.Container R : Type u₁ x y : R h₁ : x = y ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure y)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

exists (A.Pure x)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ node k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := node, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) node), eq (k₁ i) (k₂ i)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (k₁ i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

exists (λ e => e.casesOn)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₁ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₁ } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (k₁ i) (k₂ i)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) (k₂ i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

exists (λ e => e.casesOn)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∃ k₂, M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := k₂ } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) (k₂ i)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i)

https://github.com/RemyCiterin/LeanCoInd.git

69d305ae769624f460f9c1ee6a0351917f4b74cf

CoInd/FreeMonads.lean

Free.eq.bisim

[136, 1]

[158, 12]

simp only [construct, M.destruct_construct, inv, true_and]

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ M.destruct (construct (Functor.Pure x)) = { fst := A.Pure x, snd := fun e => PEmpty.casesOn (fun x => M (Container C R)) e } ∧ ∀ (i : Container.B (Container C R) (A.Pure x)), eq ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i) ((fun e => PEmpty.casesOn (fun x => M (Container C R)) e) i)

case h₀.Pure.refl C : _root_.Container R : Type u₁ x y : R ⊢ ∀ (i : Container.B (Container C R) (A.Pure x)), eq (PEmpty.rec (fun x => M (Container C R)) i) (PEmpty.rec (fun x => M (Container C R)) i)