internlm/Lean-Github huggingface dataset:
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝ : input.rhs.inv = true
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
idx✝ : Nat
h1✝ : idx✝ < ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls[idx✝] = aig.decls[idx✝]
Tactic:
rw [LawfulOperator.decl_eq (f := AIG.mkConstCached)]
Proof state after:
no goals
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_4
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
⊢ ∀ (idx : Nat) (h1 : idx < res.aig.decls.size) (h2 : idx < aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
Tactic:
rw [← hres]
Proof state after:
case h_2.h_4
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
⊢ ∀ (idx : Nat) (h1 : idx < ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls.size)
    (h2 : idx < aig.decls.size),
    ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls[idx] = aig.decls[idx]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_4
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
⊢ ∀ (idx : Nat) (h1 : idx < ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls.size)
    (h2 : idx < aig.decls.size),
    ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls[idx] = aig.decls[idx]
Tactic:
intros
Proof state after:
case h_2.h_4
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
idx✝ : Nat
h1✝ : idx✝ < ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls[idx✝] = aig.decls[idx✝]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_4
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝¹ : aig.decls[input.rhs.ref.gate] = Decl.const false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const true → input.lhs.inv = true → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const false → input.lhs.inv = false → False
hres : { decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false = res
idx✝ : Nat
h1✝ : idx✝ < ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ ({ decls := aig.decls, cache := aig.cache, inv := ⋯ }.mkConstCached false).aig.decls[idx✝] = aig.decls[idx✝]
Tactic:
rw [LawfulOperator.decl_eq (f := AIG.mkConstCached)]
Proof state after:
no goals
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_5
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat) (h1 : idx < res.aig.decls.size) (h2 : idx < aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
Tactic:
rw [← hres]
Proof state after:
case h_2.h_5
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_5
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Tactic:
intros
Proof state after:
case h_2.h_5
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_5
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Tactic:
simp
Proof state after:
no goals
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_6
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const false
heq✝¹ : input.lhs.inv = true
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat) (h1 : idx < res.aig.decls.size) (h2 : idx < aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
Tactic:
rw [← hres]
Proof state after:
case h_2.h_6
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const false
heq✝¹ : input.lhs.inv = true
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_6
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const false
heq✝¹ : input.lhs.inv = true
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Tactic:
intros
Proof state after:
case h_2.h_6
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const false
heq✝¹ : input.lhs.inv = true
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_6
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝³ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝² x✝¹ : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.lhs.ref.gate] = Decl.const false
heq✝¹ : input.lhs.inv = true
heq✝ : input.rhs.inv = false
x✝ : aig.decls[input.rhs.ref.gate] = Decl.const false → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.rhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Tactic:
simp
Proof state after:
no goals
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_7
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const false → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const true → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.lhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat) (h1 : idx < res.aig.decls.size) (h2 : idx < aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
Tactic:
rw [← hres]
Proof state after:
case h_2.h_7
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const false → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const true → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.lhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_7
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const false → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const true → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.lhs.ref.gate, hgate := ⋯ } } =
    res
⊢ ∀ (idx : Nat)
    (h1 :
      idx <
        { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
                ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls.size)
    (h2 : idx < aig.decls.size),
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
              ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls[idx] =
      aig.decls[idx]
Tactic:
intros
Proof state after:
case h_2.h_7
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const false → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const true → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.lhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Theorem: AIG.mkGateCached_decl_eq
Proof state before:
case h_2.h_7
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
input : aig.GateInput
res : Entrypoint α
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝³ : aig.cache.find? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
x✝³ x✝² : Decl α
linv✝ rinv✝ : Bool
heq✝² : aig.decls[input.rhs.ref.gate] = Decl.const true
heq✝¹ : input.lhs.inv = false
heq✝ : input.rhs.inv = false
x✝¹ : aig.decls[input.lhs.ref.gate] = Decl.const false → False
x✝ : aig.decls[input.lhs.ref.gate] = Decl.const true → False
hres :
  { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ }, ref := { gate := input.lhs.ref.gate, hgate := ⋯ } } =
    res
idx✝ : Nat
h1✝ :
  idx✝ <
    { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls.size
h2✝ : idx✝ < aig.decls.size
⊢ { aig := { decls := aig.decls, cache := aig.cache, inv := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }.aig.decls[idx✝] =
    aig.decls[idx✝]
Tactic:
simp
Proof state after:
no goals