-- Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/CachedLemmas.lean
theorem mkGateCached.go_eval_eq_mkGate_eval {aig : AIG α} {input : GateInput aig} :
    ⟦go aig input, assign⟧ = ⟦aig.mkGate input, assign⟧

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
aig : AIG α
input : aig.GateInput
⊢ ⟦assign,
      match aig.cache.get? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) with
      | some hit =>
        { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ }, ref := { gate := hit.idx, hgate := ⋯ } }
      | none =>
        match aig.decls[input.lhs.ref.gate], aig.decls[input.rhs.ref.gate], input.lhs.inv, input.rhs.inv with
        | Decl.const true, x, true, x_1 =>
          { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
        | Decl.const false, x, false, x_1 =>
          { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
        | x, Decl.const true, x_1, true =>
          { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
        | x, Decl.const false, x_1, false =>
          { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
        | Decl.const true, x, false, false =>
          { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }
        | Decl.const false, x, true, false =>
          { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
            ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }
        | x, Decl.const true, false, false =>
          { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
        | x, Decl.const false, false, true =>
          { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
        | x, x_1, x_2, x_3 =>
          if (input.lhs.ref.gate == input.rhs.ref.gate && input.lhs.inv == false && input.rhs.inv == false) = true then
            { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
              ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
          else
            if (input.lhs.ref.gate == input.rhs.ref.gate && input.lhs.inv == !input.rhs.inv) = true then
              { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
            else
              {
                aig :=
                  {
                    decls :=
                      aig.decls.push (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv),
                    cache :=
                      Cache.insert aig.decls aig.cache
                        (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv),
                    invariant := ⋯ },
                ref := { gate := aig.decls.size, hgate := ⋯ } }⟧ =
    ⟦assign, aig.mkGate input⟧

Tactic:
split

Result:
case h_1
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
aig : AIG α
input : aig.GateInput
x✝ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
hit✝ : CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv)
heq✝ : aig.cache.get? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = some hit✝
⊢ ⟦assign,
      { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ }, ref := { gate := hit✝.idx, hgate := ⋯ } }⟧ =
    ⟦assign, aig.mkGate input⟧

case h_2
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
aig : AIG α
input : aig.GateInput
x✝ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝ : aig.cache.get? (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv) = none
⊢ ⟦assign,
      match aig.decls[input.lhs.ref.gate], aig.decls[input.rhs.ref.gate], input.lhs.inv, input.rhs.inv with
      | Decl.const true, x, true, x_1 => { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
      | Decl.const false, x, false, x_1 =>
        { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
      | x, Decl.const true, x_1, true => { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
      | x, Decl.const false, x_1, false =>
        { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
      | Decl.const true, x, false, false =>
        { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
          ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }
      | Decl.const false, x, true, false =>
        { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
          ref := { gate := input.rhs.ref.gate, hgate := ⋯ } }
      | x, Decl.const true, false, false =>
        { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
          ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
      | x, Decl.const false, false, true =>
        { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
          ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
      | x, x_1, x_2, x_3 =>
        if (input.lhs.ref.gate == input.rhs.ref.gate && input.lhs.inv == false && input.rhs.inv == false) = true then
          { aig := { decls := aig.decls, cache := aig.cache, invariant := ⋯ },
            ref := { gate := input.lhs.ref.gate, hgate := ⋯ } }
        else
          if (input.lhs.ref.gate == input.rhs.ref.gate && input.lhs.inv == !input.rhs.inv) = true then
            { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false
          else
            {
              aig :=
                { decls := aig.decls.push (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv),
                  cache :=
                    Cache.insert aig.decls aig.cache
                      (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv),
                  invariant := ⋯ },
              ref := { gate := aig.decls.size, hgate := ⋯ } }⟧ =
    ⟦assign, aig.mkGate input⟧

Proof state:
case h_2.h_4
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
aig : AIG α
input : aig.GateInput
x✝⁴ : Option (CacheHit aig.decls (Decl.gate input.lhs.ref.gate input.rhs.ref.gate input.lhs.inv input.rhs.inv))
heq✝² : aig.cache.get? (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
⊢ ⟦assign, { decls := aig.decls, cache := aig.cache, invariant := ⋯ }.mkConstCached false⟧ = ⟦assign, aig.mkGate input⟧

Tactic:
next heq _ _ _ =>
simp_all [denote_idx_const heq]

Result:
no goals