l3lab/ntp-mathlib huggingface dataset:
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ pos (lor (PosNum.bit a✝ m✝) 1) = bit (a✝ || true) (bif true || false then pos m✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try 

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ pos (lor (PosNum.bit a✝ m✝) 1) = bit (a✝ || true) (bif true || false then pos m✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝)) = bit (a✝ || b✝) (pos (lor m✝ n✝))

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try 

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝)) = bit (a✝ || b✝) (pos (lor m✝ n✝))

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case gff
α : Type u_1
⊢ (false || false) = false

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case f00
α : Type u_1
⊢ 0 ||| 0 = 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 ||| pos n✝ = bif false || true then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ ||| 0 = bif true || false then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ ||| pos n✝ = pos (lor m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case p11
α : Type u_1
⊢ pos (lor 1 1) = bif true || true then 1 else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.false
α : Type u_1
n✝ : PosNum
⊢ pos (lor 1 (PosNum.bit false n✝)) = bit (true || false) (bif false || true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.true
α : Type u_1
n✝ : PosNum
⊢ pos (lor 1 (PosNum.bit true n✝)) = bit (true || true) (bif false || true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.false
α : Type u_1
m✝ : PosNum
⊢ pos (lor (PosNum.bit false m✝) 1) = bit (false || true) (bif true || false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.true
α : Type u_1
m✝ : PosNum
⊢ pos (lor (PosNum.bit true m✝) 1) = bit (true || true) (bif true || false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit false m✝) (PosNum.bit false n✝)) = bit (false || false) (pos (lor m✝ n✝))

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit false m✝) (PosNum.bit true n✝)) = bit (false || true) (pos (lor m✝ n✝))

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit true m✝) (PosNum.bit false n✝)) = bit (true || false) (pos (lor m✝ n✝))

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) := by
  -- Porting note: A name of an implicit local hypothesis is not available so
  --               `cases_type*` is used.
  apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos (lor (PosNum.bit true m✝) (PosNum.bit true n✝)) = bit (true || true) (pos (lor m✝ n✝))

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  

Proof state:
α : Type u_1
⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n

Next tactic:
apply castNum_eq_bitwise PosNum.land
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case gff
α : Type u_1
⊢ (false && false) = false

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case f00
α : Type u_1
⊢ 0 &&& 0 = 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case f0n
α : Type u_1
⊢ ∀ (n : PosNum), 0 &&& pos n = bif false && true then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case fn0
α : Type u_1
⊢ ∀ (n : PosNum), pos n &&& 0 = bif true && false then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case fnn
α : Type u_1
⊢ ∀ (m n : PosNum), pos m &&& pos n = PosNum.land m n

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.land 1 1 = bif true && true then 1 else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case p1b
α : Type u_1
⊢ ∀ (b : Bool) (n : PosNum), PosNum.land 1 (PosNum.bit b n) = bit (true && b) (bif false && true then pos n else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case pb1
α : Type u_1
⊢ ∀ (a : Bool) (m : PosNum), PosNum.land (PosNum.bit a m) 1 = bit (a && true) (bif true && false then pos m else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> 

Proof state:
case pbb
α : Type u_1
⊢ ∀ (a b : Bool) (m n : PosNum), PosNum.land (PosNum.bit a m) (PosNum.bit b n) = bit (a && b) (PosNum.land m n)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case gff
α : Type u_1
⊢ (false && false) = false

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case gff
α : Type u_1
⊢ (false && false) = false

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case f00
α : Type u_1
⊢ 0 &&& 0 = 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case f00
α : Type u_1
⊢ 0 &&& 0 = 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 &&& pos n✝ = bif false && true then pos n✝ else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 &&& pos n✝ = bif false && true then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ &&& 0 = bif true && false then pos n✝ else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ &&& 0 = bif true && false then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ &&& pos n✝ = PosNum.land m✝ n✝

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ &&& pos n✝ = PosNum.land m✝ n✝

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case p11
α : Type u_1
⊢ PosNum.land 1 1 = bif true && true then 1 else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case p11
α : Type u_1
⊢ PosNum.land 1 1 = bif true && true then 1 else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.land 1 (PosNum.bit b✝ n✝) = bit (true && b✝) (bif false && true then pos n✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.land 1 (PosNum.bit b✝ n✝) = bit (true && b✝) (bif false && true then pos n✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.land (PosNum.bit a✝ m✝) 1 = bit (a✝ && true) (bif true && false then pos m✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.land (PosNum.bit a✝ m✝) 1 = bit (a✝ && true) (bif true && false then pos m✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ && b✝) (PosNum.land m✝ n✝)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try 

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ && b✝) (PosNum.land m✝ n✝)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case gff
α : Type u_1
⊢ (false && false) = false

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f00
α : Type u_1
⊢ 0 &&& 0 = 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 &&& pos n✝ = bif false && true then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ &&& 0 = bif true && false then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ &&& pos n✝ = PosNum.land m✝ n✝

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.land 1 1 = bif true && true then 1 else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.false
α : Type u_1
n✝ : PosNum
⊢ PosNum.land 1 (PosNum.bit false n✝) = bit (true && false) (bif false && true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.true
α : Type u_1
n✝ : PosNum
⊢ PosNum.land 1 (PosNum.bit true n✝) = bit (true && true) (bif false && true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.false
α : Type u_1
m✝ : PosNum
⊢ PosNum.land (PosNum.bit false m✝) 1 = bit (false && true) (bif true && false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.true
α : Type u_1
m✝ : PosNum
⊢ PosNum.land (PosNum.bit true m✝) 1 = bit (true && true) (bif true && false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit false m✝) (PosNum.bit false n✝) = bit (false && false) (PosNum.land m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit false m✝) (PosNum.bit true n✝) = bit (false && true) (PosNum.land m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit true m✝) (PosNum.bit false n✝) = bit (true && false) (PosNum.land m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.land (PosNum.bit true m✝) (PosNum.bit true n✝) = bit (true && true) (PosNum.land m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  

Proof state:
α : Type u_1
⊢ ∀ (m n : Num), ↑(ldiff m n) = Nat.ldiff ↑m ↑n

Next tactic:
apply castNum_eq_bitwise PosNum.ldiff
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case gff
α : Type u_1
⊢ (false && !false) = false

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case f00
α : Type u_1
⊢ ldiff 0 0 = 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case f0n
α : Type u_1
⊢ ∀ (n : PosNum), ldiff 0 (pos n) = bif false && !true then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case fn0
α : Type u_1
⊢ ∀ (n : PosNum), ldiff (pos n) 0 = bif true && !false then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case fnn
α : Type u_1
⊢ ∀ (m n : PosNum), ldiff (pos m) (pos n) = PosNum.ldiff m n

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.ldiff 1 1 = bif true && !true then 1 else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case p1b
α : Type u_1
⊢ ∀ (b : Bool) (n : PosNum), PosNum.ldiff 1 (PosNum.bit b n) = bit (true && !b) (bif false && !true then pos n else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case pb1
α : Type u_1
⊢ ∀ (a : Bool) (m : PosNum), PosNum.ldiff (PosNum.bit a m) 1 = bit (a && !true) (bif true && !false then pos m else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> 

Proof state:
case pbb
α : Type u_1
⊢ ∀ (a b : Bool) (m n : PosNum), PosNum.ldiff (PosNum.bit a m) (PosNum.bit b n) = bit (a && !b) (PosNum.ldiff m n)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case gff
α : Type u_1
⊢ (false && !false) = false

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case gff
α : Type u_1
⊢ (false && !false) = false

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case f00
α : Type u_1
⊢ ldiff 0 0 = 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case f00
α : Type u_1
⊢ ldiff 0 0 = 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ ldiff 0 (pos n✝) = bif false && !true then pos n✝ else 0

Next tactic:
try cases_type* Bool