1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.minimalPeriod_apply_iterate
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply
  (IsPeriodicPt.minimalPeriod_le (minimalPeriod_pos_of_mem_periodicPts hx) _).antisymm
    ((isPeriodicPt_of_mem_periodicPts_of_isPeriodicPt_iterate hx
          (isPeriodicPt_minimalPeriod f _)).minimalPeriod_le
      (minimalPeriod_pos_of_mem_periodicPts _))
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ minimalPeriod f (f^[n] x) = minimalPeriod f x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ IsPeriodicPt f (minimalPeriod f x) (f^[n] x)

α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ f^[n] x ∈ periodicPts f

tactic: exact (isPeriodicPt_minimalPeriod f x).apply_iterate n
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ IsPeriodicPt f (minimalPeriod f x) (f^[n] x)
state_after: no goals

tactic: rcases hx with ⟨m, hm, hx⟩
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ f^[n] x ∈ periodicPts f
state_after: case intro.intro
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n✝ n m : ℕ
hm : m > 0
hx : IsPeriodicPt f m x
⊢ f^[n] x ∈ periodicPts f

tactic: exact ⟨m, hm, hx.apply_iterate n⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n✝ n m : ℕ
hm : m > 0
hx : IsPeriodicPt f m x
⊢ f^[n] x ∈ periodicPts f
state_after: no goals
Theorem: toIocDiv_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIocDiv_add_zsmul', sub_neg_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocDiv hp (a - m • p) b = toIocDiv hp a b + m
state_after: no goals
Theorem: Int.normalize_of_nonpos
File: Mathlib/Algebra/GCDMonoid/Nat.lean

tactic: obtain rfl | h := h.eq_or_lt
state_before: z : ℤ
h : z ≤ 0
⊢ normalize z = -z
state_after: case inl
h : 0 ≤ 0
⊢ normalize 0 = -0

case inr
z : ℤ
h✝ : z ≤ 0
h : z < 0
⊢ normalize z = -z

tactic: simp
state_before: case inl
h : 0 ≤ 0
⊢ normalize 0 = -0
state_after: no goals

tactic: rw [normalize_apply, normUnit_eq, if_neg (not_le_of_gt h), Units.val_neg, Units.val_one,
  mul_neg_one]
state_before: case inr
z : ℤ
h✝ : z ≤ 0
h : z < 0
⊢ normalize z = -z
state_after: no goals
Theorem: Matrix.vecAlt0_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) = v ∘ bit0
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) i = (v ∘ bit0) i

tactic: simp_rw [Function.comp, bit0, vecAlt0, vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) i = (v ∘ bit0) i
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v ⟨↑i + ↑i, ⋯⟩ else v ⟨↑i + ↑i - n, ⋯⟩) = v (i + i)

tactic: split_ifs with h <;> congr
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v ⟨↑i + ↑i, ⋯⟩ else v ⟨↑i + ↑i - n, ⋯⟩) = v (i + i)
state_after: case pos.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n

case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ ↑i + ↑i - n = (↑i + ↑i) % n

tactic: exact (Nat.mod_eq_of_lt h).symm
state_before: case pos.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n
state_after: no goals

tactic: rw [Fin.val_mk, not_lt] at h
state_before: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ ↑i + ↑i - n = (↑i + ↑i) % n
state_after: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i) % n

tactic: simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_eq_sub_mod h]
state_before: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i) % n
state_after: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i - n) % n

tactic: refine (Nat.mod_eq_of_lt ?_).symm
state_before: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i - n) % n
state_after: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n < n

tactic: omega
state_before: case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n < n
state_after: no goals
Theorem: Multiset.le_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: classical
refine le_iff_count.2 fun a ↦ ?_
obtain ⟨m', hm'⟩ := exists_cons_of_mem $ mem_map_of_mem (fun b ↦ count a (f b)) hx
rw [count_bind, hm', sum_cons]
exact Nat.le_add_right _ _
state_before: α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
⊢ f x ≤ S.bind f
state_after: no goals

tactic: refine le_iff_count.2 fun a ↦ ?_
state_before: α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
⊢ f x ≤ S.bind f
state_after: α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ count a (f x) ≤ count a (S.bind f)

tactic: obtain ⟨m', hm'⟩ := exists_cons_of_mem $ mem_map_of_mem (fun b ↦ count a (f b)) hx
state_before: α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ count a (f x) ≤ count a (S.bind f)
state_after: case intro
α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
m' : Multiset ℕ
hm' : map (fun b => count a (f b)) S = (fun b => count a (f b)) x ::ₘ m'
⊢ count a (f x) ≤ count a (S.bind f)

tactic: rw [count_bind, hm', sum_cons]
state_before: case intro
α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
m' : Multiset ℕ
hm' : map (fun b => count a (f b)) S = (fun b => count a (f b)) x ::ₘ m'
⊢ count a (f x) ≤ count a (S.bind f)
state_after: case intro
α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
m' : Multiset ℕ
hm' : map (fun b => count a (f b)) S = (fun b => count a (f b)) x ::ₘ m'
⊢ count a (f x) ≤ (fun b => count a (f b)) x + m'.sum

tactic: exact Nat.le_add_right _ _
state_before: case intro
α✝ : Type u_1
β✝ : Type v
γ : Type u_2
δ : Type u_3
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_4
β : Type u_5
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
m' : Multiset ℕ
hm' : map (fun b => count a (f b)) S = (fun b => count a (f b)) x ::ₘ m'
⊢ count a (f x) ≤ (fun b => count a (f b)) x + m'.sum
state_after: no goals
Theorem: EReal.preimage_coe_Ioi_bot
File: Mathlib/Data/Real/EReal.lean

tactic: change (WithBot.some ∘ WithTop.some) ⁻¹' (Ioi ⊥) = _
state_before: ⊢ Real.toEReal ⁻¹' Ioi ⊥ = univ
state_after: ⊢ WithBot.some ∘ WithTop.some ⁻¹' Ioi ⊥ = univ

tactic: refine preimage_comp.trans ?_
state_before: ⊢ WithBot.some ∘ WithTop.some ⁻¹' Ioi ⊥ = univ
state_after: ⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Ioi ⊥) = univ

tactic: simp only [WithBot.preimage_coe_Ioi_bot, preimage_univ]
state_before: ⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Ioi ⊥) = univ
state_after: no goals
Theorem: PartialEquiv.prod_symm
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: ext x <;> simp [prod_coe_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e : PartialEquiv α β
e' : PartialEquiv γ δ
⊢ (e.prod e').symm = e.symm.prod e'.symm
state_after: no goals
Theorem: isLeftRegular_of_mul_eq_one
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rw [h]
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : b * a = 1
⊢ IsLeftRegular (?m.14060 * a)
state_after: R : Type u_1
inst✝ : Monoid R
a b : R
h : b * a = 1
⊢ IsLeftRegular 1

tactic: exact isRegular_one.left
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : b * a = 1
⊢ IsLeftRegular 1
state_after: no goals
Theorem: CategoryTheory.Iso.inv_hom_id_triangle_hom₃
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

tactic: rw [← comp_hom₃, e.inv_hom_id, id_hom₃]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
e : A ≅ B
⊢ e.inv.hom₃ ≫ e.hom.hom₃ = 𝟙 B.obj₃
state_after: no goals
Theorem: Nat.Partrec'.tail
File: Mathlib/Computability/Halting.lean

tactic: simp
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (mOfFn fun i => (↑fun v => v.get i.succ) v) >>= f = f v.tail
state_after: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f v.tail

tactic: rw [← ofFn_get v.tail]
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f v.tail
state_after: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)

tactic: congr
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)
state_after: case e_a.e_a
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get

tactic: funext i
state_before: case e_a.e_a
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get
state_after: case e_a.e_a.h
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i

tactic: simp
state_before: case e_a.e_a.h
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i
state_after: no goals
Theorem: Nat.geom_sum_le
File: Mathlib/Algebra/GeomSum.lean

tactic: refine (Nat.le_div_iff_mul_le <| tsub_pos_of_lt hb).2 ?_
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ ∑ i ∈ range n, a / b ^ i ≤ a * b / (b - 1)
state_after: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range n, a / b ^ i) * (b - 1) ≤ a * b

tactic: cases' n with n
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range n, a / b ^ i) * (b - 1) ≤ a * b
state_after: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ (∑ i ∈ range 0, a / b ^ i) * (b - 1) ≤ a * b

case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range (n + 1), a / b ^ i) * (b - 1) ≤ a * b

tactic: rw [mul_comm]
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range (n + 1), a / b ^ i) * (b - 1) ≤ a * b
state_after: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (b - 1) * ∑ i ∈ range (n + 1), a / b ^ i ≤ a * b

tactic: exact (Nat.pred_mul_geom_sum_le a b n).trans tsub_le_self
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (b - 1) * ∑ i ∈ range (n + 1), a / b ^ i ≤ a * b
state_after: no goals

tactic: rw [sum_range_zero, zero_mul]
state_before: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ (∑ i ∈ range 0, a / b ^ i) * (b - 1) ≤ a * b
state_after: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ 0 ≤ a * b

tactic: exact Nat.zero_le _
state_before: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ 0 ≤ a * b
state_after: no goals
Theorem: IsFractionRing.mk'_num_den'
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: rw [← mk'_eq_div]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
⊢ (algebraMap A K) (num A x) / (algebraMap A K) ↑(den A x) = x
state_after: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
⊢ mk' K (num A x) (den A x) = x

tactic: apply mk'_num_den
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
⊢ mk' K (num A x) (den A x) = x
state_after: no goals
Theorem: ZMod.mul_inv_cancel_aux
File: Mathlib/Data/ZMod/Basic.lean

tactic: obtain ⟨k, rfl⟩ := natCast_zmod_surjective a
state_before: n a✝ p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
h : a ≠ 0
⊢ a * a⁻¹ = 1
state_after: case intro
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ ↑k * (↑k)⁻¹ = 1

tactic: apply coe_mul_inv_eq_one
state_before: case intro
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ ↑k * (↑k)⁻¹ = 1
state_after: case intro.h
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ k.Coprime p

tactic: apply Nat.Coprime.symm
state_before: case intro.h
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ k.Coprime p
state_after: case intro.h.a
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ p.Coprime k

tactic: rwa [Nat.Prime.coprime_iff_not_dvd Fact.out, ← CharP.cast_eq_zero_iff (ZMod p)]
state_before: case intro.h.a
n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ p.Coprime k
state_after: no goals
Theorem: Finsupp.toMultiset_single
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: rw [toMultiset_apply, sum_single_index]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
a : α
n : ℕ
⊢ toMultiset (single a n) = n • {a}
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
a : α
n : ℕ
⊢ 0 • {a} = 0

tactic: apply zero_nsmul
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
a : α
n : ℕ
⊢ 0 • {a} = 0
state_after: no goals
Theorem: Matroid.Basis'.encard_eq_encard
File: Mathlib/Data/Matroid/Restrict.lean

tactic: rw [← base_restrict_iff'] at hI hJ
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Basis' I X
hJ : M.Basis' J X
⊢ I.encard = J.encard
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : (M ↾ X).Base I
hJ : (M ↾ X).Base J
⊢ I.encard = J.encard

tactic: exact hI.card_eq_card_of_base hJ
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : (M ↾ X).Base I
hJ : (M ↾ X).Base J
⊢ I.encard = J.encard
state_after: no goals
Theorem: CategoryTheory.Functor.final_of_adjunction
File: Mathlib/CategoryTheory/Limits/Final.lean

tactic: simp [u]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map ((adj.homEquiv c f.right).symm f.hom) = f.hom
state_after: no goals

tactic: simp [u]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map ((adj.homEquiv c g.right).symm g.hom) = g.hom
state_after: no goals
Theorem: Mathlib.Meta.NormNum.IsInt.neg_to_eq
File: Mathlib/Tactic/NormNum/Result.lean

tactic: simp [Int.negOfNat_eq, Int.cast_neg]
state_before: α : Type u_1
inst✝ : Ring α
n : ℕ
⊢ ↑(Int.negOfNat n) = -↑n
state_after: no goals
Theorem: Complex.arg_neg_eq_arg_sub_pi_of_im_pos
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [arg_of_im_pos hi, arg_of_im_neg (show (-x).im < 0 from Left.neg_neg_iff.2 hi)]
state_before: a x✝ z x : ℂ
hi : 0 < x.im
⊢ (-x).arg = x.arg - π
state_after: a x✝ z x : ℂ
hi : 0 < x.im
⊢ -Real.arccos ((-x).re / abs (-x)) = Real.arccos (x.re / abs x) - π

tactic: simp [neg_div, Real.arccos_neg]
state_before: a x✝ z x : ℂ
hi : 0 < x.im
⊢ -Real.arccos ((-x).re / abs (-x)) = Real.arccos (x.re / abs x) - π
state_after: no goals
Theorem: Monoid.CoprodI.NeWord.toList_ne_nil
File: Mathlib/GroupTheory/CoprodI.lean

tactic: induction w
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ w.toList ≠ []
state_after: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ (singleton x✝ a✝).toList ≠ []

case append
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : _w₁✝.toList ≠ []
_w₂_ih✝ : _w₂✝.toList ≠ []
⊢ (_w₁✝.append _hne✝ _w₂✝).toList ≠ []

tactic: rintro ⟨rfl⟩
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ (singleton x✝ a✝).toList ≠ []
state_after: no goals

tactic: apply List.append_ne_nil_of_ne_nil_left
state_before: case append
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : _w₁✝.toList ≠ []
_w₂_ih✝ : _w₂✝.toList ≠ []
⊢ (_w₁✝.append _hne✝ _w₂✝).toList ≠ []
state_after: case append.a
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : _w₁✝.toList ≠ []
_w₂_ih✝ : _w₂✝.toList ≠ []
⊢ _w₁✝.toList ≠ []

tactic: assumption
state_before: case append.a
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : _w₁✝.toList ≠ []
_w₂_ih✝ : _w₂✝.toList ≠ []
⊢ _w₁✝.toList ≠ []
state_after: no goals
Theorem: MeasureTheory.Martingale.ae_not_tendsto_atTop_atTop
File: Mathlib/Probability/Martingale/BorelCantelli.lean

tactic: filter_upwards [hf.bddAbove_range_iff_bddBelow_range hbdd] with ω hω htop using
  unbounded_of_tendsto_atTop htop (hω.2 <| bddBelow_range_of_tendsto_atTop_atTop htop)
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Martingale f ℱ μ
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => f n ω) atTop atTop
state_after: no goals
Theorem: List.insertNth_eraseIdx_of_ge
File: Mathlib/Data/List/InsertNth.lean

tactic: simp [eraseIdx, insertNth]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
as : List α
x✝¹ : 0 < (head✝ :: as).length
x✝ : 0 ≤ 0
⊢ insertNth 0 a ((head✝ :: as).eraseIdx 0) = (insertNth (0 + 1) a (head✝ :: as)).eraseIdx 0
state_after: no goals
Theorem: Fin.sign_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: simp [cycleRange]
state_before: n : ℕ
i : Fin n
⊢ sign i.cycleRange = (-1) ^ ↑i
state_after: no goals
Theorem: CategoryTheory.InjectiveResolution.descFOne_zero_comm
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: apply J.exact₀.comp_descToInjective
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ J.cocomplex.d 0 1 ≫ descFOne f I J = descFZero f I J ≫ I.cocomplex.d 0 1
state_after: no goals
Theorem: Nat.coprime_list_prod_left_iff
File: Mathlib/Data/Nat/GCD/BigOperators.lean

tactic: induction l <;> simp [Nat.coprime_mul_iff_left, *]
state_before: ι : Type u_1
l : List ℕ
k : ℕ
⊢ l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k
state_after: no goals
Theorem: TopCat.GlueData.ι_injective
File: Mathlib/Topology/Gluing.lean

tactic: intro x y h
state_before: D : GlueData
i : D.J
⊢ Function.Injective ⇑(D.ι i)
state_after: D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
⊢ x = y

tactic: rcases (D.ι_eq_iff_rel _ _ _ _).mp h with (⟨⟨⟩⟩ | ⟨_, e₁, e₂⟩)
state_before: D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
⊢ x = y
state_after: case inl.refl
D : GlueData
i : D.J
x : ↑(D.U i)
h : (D.ι i) x = (D.ι i) x
⊢ x = x

case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f ⟨i, x⟩.fst ⟨i, y⟩.fst) w✝ = ⟨i, x⟩.snd
e₂ : (D.f ⟨i, y⟩.fst ⟨i, x⟩.fst) ((D.t ⟨i, x⟩.fst ⟨i, y⟩.fst) w✝) = ⟨i, y⟩.snd
⊢ x = y

tactic: rfl
state_before: case inl.refl
D : GlueData
i : D.J
x : ↑(D.U i)
h : (D.ι i) x = (D.ι i) x
⊢ x = x
state_after: no goals

tactic: dsimp only at *
state_before: case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f ⟨i, x⟩.fst ⟨i, y⟩.fst) w✝ = ⟨i, x⟩.snd
e₂ : (D.f ⟨i, y⟩.fst ⟨i, x⟩.fst) ((D.t ⟨i, x⟩.fst ⟨i, y⟩.fst) w✝) = ⟨i, y⟩.snd
⊢ x = y
state_after: case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f i i) w✝ = x
e₂ : (D.f i i) ((D.t i i) w✝) = y
⊢ x = y

tactic: rw [← e₁, ← e₂]
state_before: case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f i i) w✝ = x
e₂ : (D.f i i) ((D.t i i) w✝) = y
⊢ x = y
state_after: case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f i i) w✝ = x
e₂ : (D.f i i) ((D.t i i) w✝) = y
⊢ (D.f i i) w✝ = (D.f i i) ((D.t i i) w✝)

tactic: simp
state_before: case inr.intro.intro
D : GlueData
i : D.J
x y : ↑(D.U i)
h : (D.ι i) x = (D.ι i) y
w✝ : ↑(D.V (⟨i, x⟩.fst, ⟨i, y⟩.fst))
e₁ : (D.f i i) w✝ = x
e₂ : (D.f i i) ((D.t i i) w✝) = y
⊢ (D.f i i) w✝ = (D.f i i) ((D.t i i) w✝)
state_after: no goals