Theorem: AIG.denote_mkAtom (LeanSAT/AIG/Lemmas.lean)

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
⊢ ⟦aig.mkAtom var, assign⟧ = assign var
Tactic:
unfold denote denote.go
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
⊢ (match elem : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] with
    | Decl.const b => b
    | Decl.atom v => assign v
    | Decl.gate lhs rhs linv rinv =>
      let_fun this := ⋯;
      let lval := denote.go lhs (aig.mkAtom var).aig.decls assign ⋯ ⋯;
      let rval := denote.go rhs (aig.mkAtom var).aig.decls assign ⋯ ⋯;
      xor lval linv && xor rval rinv) =
    assign var

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
⊢ (match elem : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] with
    | Decl.const b => b
    | Decl.atom v => assign v
    | Decl.gate lhs rhs linv rinv =>
      let_fun this := ⋯;
      let lval := denote.go lhs (aig.mkAtom var).aig.decls assign ⋯ ⋯;
      let rval := denote.go rhs (aig.mkAtom var).aig.decls assign ⋯ ⋯;
      xor lval linv && xor rval rinv) =
    assign var
Tactic:
split
State after:
case h_1
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.const b✝
⊢ b✝ = assign var

case h_2
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var

case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var

State before:
case h_1
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.const b✝
⊢ b✝ = assign var

case h_2
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var

case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
. next heq =>
  rw [mkAtom, Array.get_push_size] at heq
  contradiction
State after:
case h_2
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var

case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var

State before:
case h_2
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var

case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
. next heq =>
  rw [mkAtom, Array.get_push_size] at heq
  injection heq with heq
  rw [heq]
State after:
case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var

State before:
case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
. next heq =>
  rw [mkAtom, Array.get_push_size] at heq
  contradiction
State after:
no goals

State before:
case h_1
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.const b✝
⊢ b✝ = assign var
Tactic:
next heq =>
rw [mkAtom, Array.get_push_size] at heq
contradiction
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.const b✝
⊢ b✝ = assign var
Tactic:
rw [mkAtom, Array.get_push_size] at heq
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq : Decl.atom var = Decl.const b✝
⊢ b✝ = assign var

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
b✝ : Bool
heq : Decl.atom var = Decl.const b✝
⊢ b✝ = assign var
Tactic:
contradiction
State after:
no goals

State before:
case h_2
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var
Tactic:
next heq =>
rw [mkAtom, Array.get_push_size] at heq
injection heq with heq
rw [heq]
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = assign var
Tactic:
rw [mkAtom, Array.get_push_size] at heq
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq : Decl.atom var = Decl.atom idx✝
⊢ assign idx✝ = assign var

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq : Decl.atom var = Decl.atom idx✝
⊢ assign idx✝ = assign var
Tactic:
injection heq with heq
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq : var = idx✝
⊢ assign idx✝ = assign var

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
idx✝ : α
heq : var = idx✝
⊢ assign idx✝ = assign var
Tactic:
rw [heq]
State after:
no goals

State before:
case h_3
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
next heq =>
rw [mkAtom, Array.get_push_size] at heq
contradiction
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
rw [mkAtom, Array.get_push_size] at heq
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
heq : Decl.atom var = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
var : α
assign : α → Bool
aig : AIG α
lidx✝ ridx✝ : Nat
linv✝ rinv✝ : Bool
heq✝ : (aig.mkAtom var).aig.decls[(aig.mkAtom var).ref.gate] = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
heq : Decl.atom var = Decl.gate lidx✝ ridx✝ linv✝ rinv✝
⊢ (let_fun this := ⋯;
    let lval := denote.go lidx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    let rval := denote.go ridx✝ (aig.mkAtom var).aig.decls assign ⋯ ⋯;
    xor lval linv✝ && xor rval rinv✝) =
    assign var
Tactic:
contradiction
State after:
no goals