-- Mathlib/Computability/Halting.lean
theorem merge' {f g} (hf : Nat.Partrec f) (hg : Nat.Partrec g) :
    ∃ h, Nat.Partrec h ∧
      ∀ a, (∀ x ∈ h a, x ∈ f a ∨ x ∈ g a) ∧ ((h a).Dom ↔ (f a).Dom ∨ (g a).Dom)

Proof state:
case intro
g : ℕ →. ℕ
hg : Partrec g
cf : Code
hf : Partrec cf.eval
⊢ ∃ h, Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ cf.eval a ∨ x ∈ g a) ∧ ((h a).Dom ↔ (cf.eval a).Dom ∨ (g a).Dom)

Tactic:
obtain ⟨cg, rfl⟩ := Code.exists_code.1 hg

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
⊢ ∃ h,
    Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ cf.eval a ∨ x ∈ cg.eval a) ∧ ((h a).Dom ↔ (cf.eval a).Dom ∨ (cg.eval a).Dom)

Proof state:
case intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n x : ℕ
h : x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
k : ℕ
⊢ (Code.evaln k cf n <|> Code.evaln k cg n) = Option.some x → x ∈ cf.eval n ∨ x ∈ cg.eval n

Tactic:
rcases e' : cf.evaln k n with - | y <;> simp <;> intro e

Result:
case intro.none
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n x : ℕ
h : x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
k : ℕ
e' : Code.evaln k cf n = Option.none
e : Code.evaln k cg n = Option.some x
⊢ x ∈ cf.eval n ∨ x ∈ cg.eval n

case intro.some
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n x : ℕ
h : x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
k y : ℕ
e' : Code.evaln k cf n = Option.some y
e : y = x
⊢ x ∈ cf.eval n ∨ x ∈ cg.eval n

Proof state:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
⊢ (∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n) ∧
    ((rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom ↔ (cf.eval n).Dom ∨ (cg.eval n).Dom)

Tactic:
refine ⟨this, ⟨fun h => (this _ ⟨h, rfl⟩).imp Exists.fst Exists.fst, ?_⟩⟩

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
⊢ (cf.eval n).Dom ∨ (cg.eval n).Dom → (rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom

Proof state:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
⊢ ∃ h,
    Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ cf.eval a ∨ x ∈ cg.eval a) ∧ ((h a).Dom ↔ (cf.eval a).Dom ∨ (cg.eval a).Dom)

Tactic:
refine ⟨_, this, fun n => ?_⟩

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
⊢ (∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n) ∧
    ((rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom ↔ (cf.eval n).Dom ∨ (cg.eval n).Dom)

Proof state:
case intro.intro.inr.intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
x k : ℕ
e : Code.evaln k cg n = Option.some x
⊢ ∃ a, a ∈ (Code.evaln k cf n <|> Code.evaln k cg n)

Tactic:
rcases cf.evaln k n with - | y

Result:
case intro.intro.inr.intro.intro.none
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
x k : ℕ
e : Code.evaln k cg n = Option.some x
⊢ ∃ a, a ∈ (Option.none <|> Code.evaln k cg n)

case intro.intro.inr.intro.intro.some
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
x k : ℕ
e : Code.evaln k cg n = Option.some x
y : ℕ
⊢ ∃ a, a ∈ (Option.some y <|> Code.evaln k cg n)

Proof state:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
h : (cf.eval n).Dom ∨ (cg.eval n).Dom
⊢ (rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom

Tactic:
rw [Nat.rfindOpt_dom]

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
h : (cf.eval n).Dom ∨ (cg.eval n).Dom
⊢ ∃ n_1 a, a ∈ (Code.evaln n_1 cf n <|> Code.evaln n_1 cg n)

Proof state:
case intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n x : ℕ
h : x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
k : ℕ
e : x ∈ (Code.evaln k cf n <|> Code.evaln k cg n)
⊢ x ∈ cf.eval n ∨ x ∈ cg.eval n

Tactic:
revert e

Result:
case intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n x : ℕ
h : x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
k : ℕ
⊢ x ∈ (Code.evaln k cf n <|> Code.evaln k cg n) → x ∈ cf.eval n ∨ x ∈ cg.eval n

Proof state:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
⊢ (cf.eval n).Dom ∨ (cg.eval n).Dom → (rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom

Tactic:
intro h

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this✝ : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
n : ℕ
this : ∀ x ∈ rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n
h : (cf.eval n).Dom ∨ (cg.eval n).Dom
⊢ (rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n).Dom

Proof state:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
⊢ ∃ h,
    Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ cf.eval a ∨ x ∈ cg.eval a) ∧ ((h a).Dom ↔ (cf.eval a).Dom ∨ (cg.eval a).Dom)

Tactic:
have : Nat.Partrec fun n => Nat.rfindOpt fun k => cf.evaln k n <|> cg.evaln k n :=
  Partrec.nat_iff.1
    (Partrec.rfindOpt <|
      Primrec.option_orElse.to_comp.comp
        (Code.evaln_prim.to_comp.comp <| (snd.pair (const cf)).pair fst)
        (Code.evaln_prim.to_comp.comp <| (snd.pair (const cg)).pair fst))

Result:
case intro.intro
cf : Code
hf : Partrec cf.eval
cg : Code
hg : Partrec cg.eval
this : Partrec fun n => rfindOpt fun k => Code.evaln k cf n <|> Code.evaln k cg n
⊢ ∃ h,
    Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ cf.eval a ∨ x ∈ cg.eval a) ∧ ((h a).Dom ↔ (cf.eval a).Dom ∨ (cg.eval a).Dom)