1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Num.castNum_testBit
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [show (Num.zero : Nat) = 0 from rfl, Nat.zero_testBit]
state_before: case zero
α : Type u_1
n : ℕ
⊢ false = (↑zero).testBit n
state_after: no goals

tactic: rw [cast_pos]
state_before: case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ m.testBit n = (↑(pos m)).testBit n
state_after: case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ m.testBit n = (↑m).testBit n

tactic: induction' n with n IH generalizing m <;> cases' m with m m
    <;> dsimp only [PosNum.testBit, Nat.zero_eq]
state_before: case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ m.testBit n = (↑m).testBit n
state_after: case pos.zero.one
α : Type u_1
⊢ true = (↑one).testBit 0

case pos.zero.bit1
α : Type u_1
m : PosNum
⊢ true = (↑m.bit1).testBit 0

case pos.zero.bit0
α : Type u_1
m : PosNum
⊢ false = (↑m.bit0).testBit 0

case pos.succ.one
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
⊢ false = (↑one).testBit (n + 1)

case pos.succ.bit1
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
m : PosNum
⊢ m.testBit n = (↑m.bit1).testBit (n + 1)

case pos.succ.bit0
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
m : PosNum
⊢ m.testBit n = (↑m.bit0).testBit (n + 1)

tactic: rfl
state_before: case pos.zero.one
α : Type u_1
⊢ true = (↑one).testBit 0
state_after: no goals

tactic: rw [PosNum.cast_bit1, ← Nat.bit_true, Nat.testBit_bit_zero]
state_before: case pos.zero.bit1
α : Type u_1
m : PosNum
⊢ true = (↑m.bit1).testBit 0
state_after: no goals

tactic: rw [PosNum.cast_bit0, ← Nat.bit_false, Nat.testBit_bit_zero]
state_before: case pos.zero.bit0
α : Type u_1
m : PosNum
⊢ false = (↑m.bit0).testBit 0
state_after: no goals

tactic: simp
state_before: case pos.succ.one
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
⊢ false = (↑one).testBit (n + 1)
state_after: no goals

tactic: rw [PosNum.cast_bit1, ← Nat.bit_true, Nat.testBit_bit_succ, IH]
state_before: case pos.succ.bit1
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
m : PosNum
⊢ m.testBit n = (↑m.bit1).testBit (n + 1)
state_after: no goals

tactic: rw [PosNum.cast_bit0, ← Nat.bit_false, Nat.testBit_bit_succ, IH]
state_before: case pos.succ.bit0
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n
m : PosNum
⊢ m.testBit n = (↑m.bit0).testBit (n + 1)
state_after: no goals
Theorem: Nat.two_mul_div_two_add_one_of_odd
File: Mathlib/Algebra/Ring/Parity.lean

tactic: rw [← odd_iff.mp h, div_add_mod]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n : ℕ
h : Odd n
⊢ 2 * (n / 2) + 1 = n
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_compl_add_restrict
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [add_comm, restrict_add_restrict_compl hs]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ μ.restrict sᶜ + μ.restrict s = μ
state_after: no goals
Theorem: Finset.filter_le_eq_Ici
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderTop α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => a ≤ x
⊢ filter (fun x => a ≤ x) univ = Ici a
state_after: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderTop α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => a ≤ x
a✝ : α
⊢ a✝ ∈ filter (fun x => a ≤ x) univ ↔ a✝ ∈ Ici a

tactic: simp
state_before: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderTop α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => a ≤ x
a✝ : α
⊢ a✝ ∈ filter (fun x => a ≤ x) univ ↔ a✝ ∈ Ici a
state_after: no goals
Theorem: egauge_le_of_smul_mem
File: Mathlib/Analysis/Convex/EGauge.lean

tactic: rcases eq_or_ne c 0 with rfl | hc
state_before: 𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
⊢ egauge 𝕜 s x ≤ (↑‖c‖₊)⁻¹
state_after: case inl
𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x y : E
r : ℝ≥0∞
h : 0 • x ∈ s
⊢ egauge 𝕜 s x ≤ (↑‖0‖₊)⁻¹

case inr
𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
hc : c ≠ 0
⊢ egauge 𝕜 s x ≤ (↑‖c‖₊)⁻¹

tactic: simp
state_before: case inl
𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x y : E
r : ℝ≥0∞
h : 0 • x ∈ s
⊢ egauge 𝕜 s x ≤ (↑‖0‖₊)⁻¹
state_after: no goals

tactic: exact (egauge_le_of_smul_mem_of_ne h hc).trans ENNReal.coe_inv_le
state_before: case inr
𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
hc : c ≠ 0
⊢ egauge 𝕜 s x ≤ (↑‖c‖₊)⁻¹
state_after: no goals
Theorem: ZMod.ringEquivCongr_val
File: Mathlib/Data/ZMod/Basic.lean

tactic: subst h
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a b : ℕ
h : a = b
x : ZMod a
⊢ ((ringEquivCongr h) x).val = x.val
state_after: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
x : ZMod a
⊢ ((ringEquivCongr ⋯) x).val = x.val

tactic: cases a <;> rfl
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
x : ZMod a
⊢ ((ringEquivCongr ⋯) x).val = x.val
state_after: no goals
Theorem: TypeVec.id_eq_nilFun
File: Mathlib/Data/TypeVec.lean

tactic: ext x
state_before: n : ℕ
α : TypeVec.{u_1} 0
⊢ id = nilFun
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} 0
x : Fin2 0
x✝ : α x
⊢ id x x✝ = nilFun x x✝

tactic: cases x
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} 0
x : Fin2 0
x✝ : α x
⊢ id x x✝ = nilFun x x✝
state_after: no goals
Theorem: NNRat.divNat_mul_divNat
File: Mathlib/Data/NNRat/Defs.lean

tactic: ext
state_before: p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ divNat n₁ d₁ * divNat n₂ d₂ = divNat (n₁ * n₂) (d₁ * d₂)
state_after: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ ↑(divNat n₁ d₁ * divNat n₂ d₂) = ↑(divNat (n₁ * n₂) (d₁ * d₂))

tactic: push_cast
state_before: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ ↑(divNat n₁ d₁ * divNat n₂ d₂) = ↑(divNat (n₁ * n₂) (d₁ * d₂))
state_after: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ Rat.divInt ↑n₁ ↑d₁ * Rat.divInt ↑n₂ ↑d₂ = Rat.divInt (↑n₁ * ↑n₂) (↑d₁ * ↑d₂)

tactic: exact Rat.divInt_mul_divInt _ _ (mod_cast hd₁) (mod_cast hd₂)
state_before: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ Rat.divInt ↑n₁ ↑d₁ * Rat.divInt ↑n₂ ↑d₂ = Rat.divInt (↑n₁ * ↑n₂) (↑d₁ * ↑d₂)
state_after: no goals
Theorem: List.modifyHead_cons
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: rw [modifyHead]
state_before: α : Type u_1
a : α
l : List α
f : α → α
⊢ modifyHead f (a :: l) = f a :: l
state_after: no goals
Theorem: neg_dvd
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

tactic: simp only [Equiv.neg_symm, Equiv.neg_apply, mul_neg, neg_mul, neg_neg, Dvd.dvd]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semigroup α
inst✝ : HasDistribNeg α
a b c : α
⊢ (∃ b_1, b = -a * (Equiv.symm (Equiv.neg α)) b_1) ↔ a ∣ b
state_after: no goals
Theorem: DFinsupp.toLex_monotone
File: Mathlib/Data/DFinsupp/Lex.lean

tactic: intro a b h
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
⊢ Monotone ⇑toLex
state_after: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
⊢ toLex a ≤ toLex b

tactic: refine le_of_lt_or_eq (or_iff_not_imp_right.2 fun hne ↦ ?_)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
⊢ toLex a ≤ toLex b
state_after: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
hne : ¬toLex a = toLex b
⊢ toLex a < toLex b

tactic: classical
exact ⟨Finset.min' _ (nonempty_neLocus_iff.2 hne),
  fun j hj ↦ not_mem_neLocus.1 fun h ↦ (Finset.min'_le _ _ h).not_lt hj,
  (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
hne : ¬toLex a = toLex b
⊢ toLex a < toLex b
state_after: no goals

tactic: exact ⟨Finset.min' _ (nonempty_neLocus_iff.2 hne),
  fun j hj ↦ not_mem_neLocus.1 fun h ↦ (Finset.min'_le _ _ h).not_lt hj,
  (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
hne : ¬toLex a = toLex b
⊢ toLex a < toLex b
state_after: no goals
Theorem: Submodule.ker_liftQ_eq_bot
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [ker_liftQ, le_antisymm h h', mkQ_map_self]
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
h' : ker f ≤ p
⊢ ker (p.liftQ f h) = ⊥
state_after: no goals
Theorem: LinearMap.mul_injective
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: letI : Nontrivial A := ⟨⟨x, 0, hx⟩⟩
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
⊢ Function.Injective ⇑((mul R A) x)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
⊢ Function.Injective ⇑((mul R A) x)

tactic: letI := NoZeroDivisors.to_isDomain A
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
⊢ Function.Injective ⇑((mul R A) x)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this✝ : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
this : IsDomain A := NoZeroDivisors.to_isDomain A
⊢ Function.Injective ⇑((mul R A) x)

tactic: exact mul_right_injective₀ hx
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this✝ : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
this : IsDomain A := NoZeroDivisors.to_isDomain A
⊢ Function.Injective ⇑((mul R A) x)
state_after: no goals
Theorem: Ideal.absNorm_top
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: rw [← Ideal.one_eq_top, _root_.map_one]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
⊢ absNorm ⊤ = 1
state_after: no goals
Theorem: Nat.add_mod_eq_ite
File: Mathlib/Data/Nat/Defs.lean

tactic: cases k
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ (m + n) % k = if k ≤ m % k + n % k then m % k + n % k - k else m % k + n % k
state_after: case zero
a b c d m n : ℕ
p q : ℕ → Prop
⊢ (m + n) % 0 = if 0 ≤ m % 0 + n % 0 then m % 0 + n % 0 - 0 else m % 0 + n % 0

case succ
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
⊢ (m + n) % (n✝ + 1) =
    if n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1) then m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) else m % (n✝ + 1) + n % (n✝ + 1)

tactic: rw [Nat.add_mod]
state_before: case succ
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
⊢ (m + n) % (n✝ + 1) =
    if n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1) then m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) else m % (n✝ + 1) + n % (n✝ + 1)
state_after: case succ
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) =
    if n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1) then m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) else m % (n✝ + 1) + n % (n✝ + 1)

tactic: split_ifs with h
state_before: case succ
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) =
    if n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1) then m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) else m % (n✝ + 1) + n % (n✝ + 1)
state_after: case pos
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) = m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1)

case neg
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : ¬n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) = m % (n✝ + 1) + n % (n✝ + 1)

tactic: simp
state_before: case zero
a b c d m n : ℕ
p q : ℕ → Prop
⊢ (m + n) % 0 = if 0 ≤ m % 0 + n % 0 then m % 0 + n % 0 - 0 else m % 0 + n % 0
state_after: no goals

tactic: rw [Nat.mod_eq_sub_mod h, Nat.mod_eq_of_lt]
state_before: case pos
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) = m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1)
state_after: case pos
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) < n✝ + 1

tactic: exact (Nat.sub_lt_iff_lt_add h).mpr (Nat.add_lt_add (m.mod_lt (zero_lt_succ _))
  (n.mod_lt (zero_lt_succ _)))
state_before: case pos
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ m % (n✝ + 1) + n % (n✝ + 1) - (n✝ + 1) < n✝ + 1
state_after: no goals

tactic: exact Nat.mod_eq_of_lt (Nat.lt_of_not_ge h)
state_before: case neg
a b c d m n : ℕ
p q : ℕ → Prop
n✝ : ℕ
h : ¬n✝ + 1 ≤ m % (n✝ + 1) + n % (n✝ + 1)
⊢ (m % (n✝ + 1) + n % (n✝ + 1)) % (n✝ + 1) = m % (n✝ + 1) + n % (n✝ + 1)
state_after: no goals
Theorem: Behrend.map_eq_iff
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: refine ⟨fun h => ?_, fun h => by rw [map_succ', map_succ', h.1, h.2]⟩
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
⊢ (map d) x₁ = (map d) x₂ ↔ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : (map d) x₁ = (map d) x₂
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)

tactic: have : x₁ 0 = x₂ 0 := by
  rw [← mod_eq_of_lt (hx₁ _), ← map_mod, ← mod_eq_of_lt (hx₂ _), ← map_mod, h]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : (map d) x₁ = (map d) x₂
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : (map d) x₁ = (map d) x₂
this : x₁ 0 = x₂ 0
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)

tactic: rw [map_succ, map_succ, this, add_right_inj, mul_eq_mul_right_iff] at h
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : (map d) x₁ = (map d) x₂
this : x₁ 0 = x₂ 0
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : ∑ x : Fin n, x₁ x.succ * d ^ ↑x = ∑ x : Fin n, x₂ x.succ * d ^ ↑x ∨ d = 0
this : x₁ 0 = x₂ 0
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)

tactic: exact ⟨this, h.resolve_right (pos_of_gt (hx₁ 0)).ne'⟩
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : ∑ x : Fin n, x₁ x.succ * d ^ ↑x = ∑ x : Fin n, x₂ x.succ * d ^ ↑x ∨ d = 0
this : x₁ 0 = x₂ 0
⊢ x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)
state_after: no goals

tactic: rw [map_succ', map_succ', h.1, h.2]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : x₁ 0 = x₂ 0 ∧ (map d) (x₁ ∘ Fin.succ) = (map d) (x₂ ∘ Fin.succ)
⊢ (map d) x₁ = (map d) x₂
state_after: no goals

tactic: rw [← mod_eq_of_lt (hx₁ _), ← map_mod, ← mod_eq_of_lt (hx₂ _), ← map_mod, h]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
x₁ x₂ : Fin n.succ → ℕ
hx₁ : ∀ (i : Fin n.succ), x₁ i < d
hx₂ : ∀ (i : Fin n.succ), x₂ i < d
h : (map d) x₁ = (map d) x₂
⊢ x₁ 0 = x₂ 0
state_after: no goals
Theorem: MeasureTheory.integral_eq_zero_of_ae
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp [integral_congr_ae hf, integral_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → G
hf : f =ᶠ[ae μ] 0
⊢ ∫ (a : α), f a ∂μ = 0
state_after: no goals
Theorem: Real.hasStrictDerivAt_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: convert sinhHomeomorph.toPartialHomeomorph.hasStrictDerivAt_symm (mem_univ x) (cosh_pos _).ne'
  (hasStrictDerivAt_sinh _) using 2
state_before: x✝ y x : ℝ
⊢ HasStrictDerivAt arsinh (√(1 + x ^ 2))⁻¹ x
state_after: case h.e'_7.h.e'_3
x✝ y x : ℝ
⊢ √(1 + x ^ 2) = cosh (↑sinhHomeomorph.toPartialHomeomorph.symm x)

tactic: exact (cosh_arsinh _).symm
state_before: case h.e'_7.h.e'_3
x✝ y x : ℝ
⊢ √(1 + x ^ 2) = cosh (↑sinhHomeomorph.toPartialHomeomorph.symm x)
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_tensor''
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : MonoidalCategory C
X Y : C
⊢ (α_ (𝟙_ C) X Y).hom ≫ (λ_ (X ⊗ Y)).hom = (λ_ X).hom ⊗ 𝟙 Y
state_after: no goals
Theorem: mem_const_vsub_affineSegment
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [← affineSegment_const_vsub_image, (vsub_right_injective p).mem_set_image]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p : P
⊢ p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y
state_after: no goals
Theorem: Matroid.Indep.subset_basis'_of_subset
File: Mathlib/Data/Matroid/Basic.lean

tactic: simp_rw [basis'_iff_basis_inter_ground]
state_before: α : Type u_1
M : Matroid α
I X : Set α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis' J X ∧ I ⊆ J
state_after: α : Type u_1
M : Matroid α
I X : Set α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis J (X ∩ M.E) ∧ I ⊆ J

tactic: exact hI.subset_basis_of_subset (subset_inter hIX hI.subset_ground)
state_before: α : Type u_1
M : Matroid α
I X : Set α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis J (X ∩ M.E) ∧ I ⊆ J
state_after: no goals
Theorem: Batteries.HashMap.empty_find?
File: .lake/packages/batteries/Batteries/Data/HashMap/Lemmas.lean

tactic: simp [find?, Imp.find?]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
a : α
⊢ ∅.find? a = none
state_after: no goals
Theorem: PartENat.toWithTop_le
File: Mathlib/Data/Nat/PartENat.lean

tactic: induction y using PartENat.casesOn generalizing hy
state_before: x y : PartENat
hx : Decidable x.Dom
hy : Decidable y.Dom
⊢ x.toWithTop ≤ y.toWithTop ↔ x ≤ y
state_after: case a
x : PartENat
hx : Decidable x.Dom
hy : Decidable ⊤.Dom
⊢ x.toWithTop ≤ ⊤.toWithTop ↔ x ≤ ⊤

case a
x : PartENat
hx : Decidable x.Dom
n✝ : ℕ
hy : Decidable (↑n✝).Dom
⊢ x.toWithTop ≤ (↑n✝).toWithTop ↔ x ≤ ↑n✝

tactic: induction x using PartENat.casesOn generalizing hx
state_before: case a
x : PartENat
hx : Decidable x.Dom
n✝ : ℕ
hy : Decidable (↑n✝).Dom
⊢ x.toWithTop ≤ (↑n✝).toWithTop ↔ x ≤ ↑n✝
state_after: case a.a
n✝ : ℕ
hy : Decidable (↑n✝).Dom
hx : Decidable ⊤.Dom
⊢ ⊤.toWithTop ≤ (↑n✝).toWithTop ↔ ⊤ ≤ ↑n✝

case a.a
n✝¹ : ℕ
hy : Decidable (↑n✝¹).Dom
n✝ : ℕ
hx : Decidable (↑n✝).Dom
⊢ (↑n✝).toWithTop ≤ (↑n✝¹).toWithTop ↔ ↑n✝ ≤ ↑n✝¹

tactic: simp
state_before: case a
x : PartENat
hx : Decidable x.Dom
hy : Decidable ⊤.Dom
⊢ x.toWithTop ≤ ⊤.toWithTop ↔ x ≤ ⊤
state_after: no goals

tactic: simp
state_before: case a.a
n✝ : ℕ
hy : Decidable (↑n✝).Dom
hx : Decidable ⊤.Dom
⊢ ⊤.toWithTop ≤ (↑n✝).toWithTop ↔ ⊤ ≤ ↑n✝
state_after: no goals

tactic: simp
state_before: case a.a
n✝¹ : ℕ
hy : Decidable (↑n✝¹).Dom
n✝ : ℕ
hx : Decidable (↑n✝).Dom
⊢ (↑n✝).toWithTop ≤ (↑n✝¹).toWithTop ↔ ↑n✝ ≤ ↑n✝¹
state_after: no goals
Theorem: List.head?_cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: rw [head?_eq_head, head_cyclicPermutations]
state_before: α : Type u
l✝ l' l : List α
⊢ l.cyclicPermutations.head? = some l
state_after: no goals
Theorem: IsDedekindDomain.HeightOneSpectrum.valuation_exists_uniformizer
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

tactic: obtain ⟨r, hr⟩ := v.int_valuation_exists_uniformizer
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))
state_after: case intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))

tactic: use algebraMap R K r
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))
state_after: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.valuation ((algebraMap R K) r) = ↑(ofAdd (-1))

tactic: rw [valuation_def, Valuation.extendToLocalization_apply_map_apply]
state_before: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.valuation ((algebraMap R K) r) = ↑(ofAdd (-1))
state_after: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.intValuation r = ↑(ofAdd (-1))

tactic: exact hr
state_before: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.intValuation r = ↑(ofAdd (-1))
state_after: no goals