Theorem: LO.FirstOrder.UFormula.ex_primrec (Logic/FirstOrder/Computability/Formula.lean)

State before:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
⊢ Primrec ex
Tactic:
have := w_mk₁ (β := Edge L μ) (fun (_ : Unit) => (false, Sum.inr $ Sum.inr $ Sum.inr ())) (by rintro ⟨⟩; simp[Edge]) (const _)
State after:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
this : Primrec₂ fun x w => WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x) fun x => w
⊢ Primrec ex

State before:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
this : Primrec₂ fun x w => WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x) fun x => w
⊢ Primrec ex
Tactic:
have := (Primrec.of_equiv_symm (e := equivW L μ)).comp
  ((this.comp (Primrec.const ()) Primrec.id).comp (Primrec.of_equiv (e := equivW L μ)))
State after:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
this✝ : Primrec₂ fun x w => WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x) fun x => w
this :
  Primrec fun a =>
    (equivW L μ).symm (WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) ()) fun x => id ((equivW L μ) a))
⊢ Primrec ex

State before:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
this✝ : Primrec₂ fun x w => WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x) fun x => w
this :
  Primrec fun a =>
    (equivW L μ).symm (WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) ()) fun x => id ((equivW L μ) a))
⊢ Primrec ex
Tactic:
exact this.of_eq (fun p => by simp)
State after:
no goals

State before:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
⊢ ∀ (x : Unit), Fintype.card (Edge L μ ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x)) = 1
Tactic:
rintro ⟨⟩
State after:
case unit
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
⊢ Fintype.card (Edge L μ ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) PUnit.unit)) = 1

State before:
case unit
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
⊢ Fintype.card (Edge L μ ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) PUnit.unit)) = 1
Tactic:
simp[Edge]
State after:
no goals

State before:
L : Language
μ : Type v
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
this✝ : Primrec₂ fun x w => WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) x) fun x => w
this :
  Primrec fun a =>
    (equivW L μ).symm (WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) ()) fun x => id ((equivW L μ) a))
p : UFormula L μ
⊢ (equivW L μ).symm (WType.mk ((fun x => (false, Sum.inr (Sum.inr (Sum.inr ())))) ()) fun x => id ((equivW L μ) p)) =
    p.ex
Tactic:
simp
State after:
no goals