1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.Walk.support_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : G.Walk u v
hu : u = u'
hv : v = v'
⊢ (p.copy hu hv).support = p.support
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : G.Walk u' v'
⊢ (p.copy ⋯ ⋯).support = p.support

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : G.Walk u' v'
⊢ (p.copy ⋯ ⋯).support = p.support
state_after: no goals
Theorem: Function.Injective.lieAlgebra_isSolvable
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: obtain ⟨k, hk⟩ := id h₁
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
⊢ IsSolvable R L'
state_after: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ IsSolvable R L'

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ IsSolvable R L'
state_after: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ derivedSeries R L' k = ⊥

tactic: apply LieIdeal.bot_of_map_eq_bot h₂
state_before: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ derivedSeries R L' k = ⊥
state_after: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) = ⊥

tactic: rw [eq_bot_iff, ← hk]
state_before: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) = ⊥
state_after: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) ≤ derivedSeries R L k

tactic: apply LieIdeal.derivedSeries_map_le
state_before: case h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ⇑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) ≤ derivedSeries R L k
state_after: no goals
Theorem: Int.ofNat_add_negSucc_of_ge
File: Mathlib/Data/Int/Defs.lean

tactic: rw [negSucc_eq, ofNat_eq_natCast, ofNat_eq_natCast, ← natCast_one, ← natCast_add,
  ← Int.sub_eq_add_neg, ← Int.natCast_sub h]
state_before: a b c d m✝ n✝ : ℤ
m n : ℕ
h : n.succ ≤ m
⊢ ofNat m + -[n+1] = ofNat (m - n.succ)
state_after: no goals
Theorem: Surreal.double_powHalf_succ_eq_powHalf
File: Mathlib/SetTheory/Surreal/Dyadic.lean

tactic: rw [two_mul]
state_before: n : ℕ
⊢ 2 * powHalf (n + 1) = powHalf n
state_after: n : ℕ
⊢ powHalf (n + 1) + powHalf (n + 1) = powHalf n

tactic: exact Quotient.sound (PGame.add_powHalf_succ_self_eq_powHalf n)
state_before: n : ℕ
⊢ powHalf (n + 1) + powHalf (n + 1) = powHalf n
state_after: no goals
Theorem: Tree.numLeaves_pos
File: Mathlib/Data/Tree/Basic.lean

tactic: rw [numLeaves_eq_numNodes_succ]
state_before: α : Type u
x : Tree α
⊢ 0 < x.numLeaves
state_after: α : Type u
x : Tree α
⊢ 0 < x.numNodes + 1

tactic: exact x.numNodes.zero_lt_succ
state_before: α : Type u
x : Tree α
⊢ 0 < x.numNodes + 1
state_after: no goals
Theorem: List.Nodup.nthLe_inj_iff
File: Mathlib/Data/List/Nodup.lean

tactic: simp (config := { contextual := true })
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : l.Nodup
i j : ℕ
hi : i < l.length
hj : j < l.length
⊢ i = j → l.nthLe i hi = l.nthLe j hj
state_after: no goals
Theorem: isGenericPoint_iff_specializes
File: Mathlib/Topology/Sober.lean

tactic: simp only [specializes_iff_mem_closure, IsGenericPoint, Set.ext_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
⊢ IsGenericPoint x S ↔ ∀ (y : α), x ⤳ y ↔ y ∈ S
state_after: no goals
Theorem: OrderMonoidWithZeroHom.cancel_left
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f g✝ : α →*₀o β
g : β →*₀o γ
f₁ f₂ : α →*₀o β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
Theorem: List.next_cons_concat
File: Mathlib/Data/List/Cycle.lean

tactic: rw [next, nextOr_concat]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ (y :: l ++ [x]).next x h = y
state_after: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ (y :: l ++ [x]).get ⟨0, ⋯⟩ = y

case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ x ∉ y :: l

tactic: rfl
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ (y :: l ++ [x]).get ⟨0, ⋯⟩ = y
state_after: no goals

tactic: simp [hy, hx]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ x ∉ y :: l
state_after: no goals
Theorem: List.length_eq_countP_add_countP
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: rfl
state_before: case nil
α : Type u_1
p q : α → Bool
⊢ [].length = countP p [] + countP (fun a => decide ¬p a = true) []
state_after: no goals

tactic: rw [countP_cons_of_pos _ _ h, countP_cons_of_neg _ _ _, length, ih]
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : p x = true
⊢ (x :: h✝).length = countP p (x :: h✝) + countP (fun a => decide ¬p a = true) (x :: h✝)
state_after: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : p x = true
⊢ countP p h✝ + countP (fun a => decide ¬p a = true) h✝ + 1 = countP p h✝ + 1 + countP (fun a => decide ¬p a = true) h✝

α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : p x = true
⊢ ¬(decide ¬p x = true) = true

tactic: rw [Nat.add_assoc, Nat.add_comm _ 1, Nat.add_assoc]
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : p x = true
⊢ countP p h✝ + countP (fun a => decide ¬p a = true) h✝ + 1 = countP p h✝ + 1 + countP (fun a => decide ¬p a = true) h✝
state_after: no goals

tactic: simp only [h, not_true_eq_false, decide_False, not_false_eq_true]
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : p x = true
⊢ ¬(decide ¬p x = true) = true
state_after: no goals

tactic: rw [countP_cons_of_pos (fun a => ¬p a) _ _, countP_cons_of_neg _ _ h, length, ih]
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : ¬p x = true
⊢ (x :: h✝).length = countP p (x :: h✝) + countP (fun a => decide ¬p a = true) (x :: h✝)
state_after: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : ¬p x = true
⊢ countP p h✝ + countP (fun a => decide ¬p a = true) h✝ + 1 =
    countP p h✝ + (countP (fun a => decide ¬p a = true) h✝ + 1)

α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : ¬p x = true
⊢ (fun a => decide ¬p a = true) x = true

tactic: rfl
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : ¬p x = true
⊢ countP p h✝ + countP (fun a => decide ¬p a = true) h✝ + 1 =
    countP p h✝ + (countP (fun a => decide ¬p a = true) h✝ + 1)
state_after: no goals

tactic: simp only [h, not_false_eq_true, decide_True]
state_before: α : Type u_1
p q : α → Bool
x : α
h✝ : List α
ih : h✝.length = countP p h✝ + countP (fun a => decide ¬p a = true) h✝
h : ¬p x = true
⊢ (fun a => decide ¬p a = true) x = true
state_after: no goals
Theorem: IsUnit.mul_left_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rcases hu with ⟨u, rfl⟩
state_before: α : Type u_1
inst✝ : CommMonoid α
a b u : α
hu : IsUnit u
⊢ u * a ∣ b ↔ a ∣ b
state_after: case intro
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ ↑u * a ∣ b ↔ a ∣ b

tactic: apply Units.mul_left_dvd
state_before: case intro
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ ↑u * a ∣ b ↔ a ∣ b
state_after: no goals
Theorem: NormedAddGroupHom.mkNormedAddGroupHom_norm_le'
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : V₁ →+ V₂
C : ℝ
h : ∀ (x : V₁), ‖f x‖ ≤ C * ‖x‖
x : V₁
⊢ C * ‖x‖ ≤ max C 0 * ‖x‖
state_after: case h
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : V₁ →+ V₂
C : ℝ
h : ∀ (x : V₁), ‖f x‖ ≤ C * ‖x‖
x : V₁
⊢ C ≤ max C 0

tactic: apply le_max_left
state_before: case h
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : V₁ →+ V₂
C : ℝ
h : ∀ (x : V₁), ‖f x‖ ≤ C * ‖x‖
x : V₁
⊢ C ≤ max C 0
state_after: no goals
Theorem: Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: convert rpow_sum_le_const_mul_sum_rpow s f hp using 2 <;> apply sum_congr rfl <;> intro i hi <;>
  simp only [abs_of_nonneg, hf i hi]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
hf : ∀ i ∈ s, 0 ≤ f i
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: no goals
Theorem: antivaryOn_iff_forall_mul_nonpos
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp only [smul_eq_mul, antivaryOn_iff_forall_smul_nonpos]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ AntivaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → (f j - f i) * (g j - g i) ≤ 0
state_after: no goals
Theorem: pi_norm_le_iff_of_nonneg'
File: Mathlib/Analysis/Normed/Group/Constructions.lean

tactic: simp only [← dist_one_right, dist_pi_le_iff hr, Pi.one_apply]
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
π : ι → Type u_4
inst✝² : Fintype ι
inst✝¹ : (i : ι) → SeminormedGroup (π i)
inst✝ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
hr : 0 ≤ r
⊢ ‖x‖ ≤ r ↔ ∀ (i : ι), ‖x i‖ ≤ r
state_after: no goals
Theorem: PosNum.cmp_swap
File: Mathlib/Data/Num/Lemmas.lean

tactic: induction' m with m IH m IH <;> intro n <;> cases' n with n n <;> unfold cmp <;>
  try { rfl } <;> rw [← IH] <;> cases cmp m n <;> rfl
state_before: α : Type u_1
m : PosNum
⊢ ∀ (n : PosNum), (m.cmp n).swap = n.cmp m
state_after: no goals

tactic: rfl
state_before: case bit0.one
α : Type u_1
m : PosNum
IH : ∀ (n : PosNum), (m.cmp n).swap = n.cmp m
⊢ Ordering.gt.swap = Ordering.lt
state_after: no goals
Theorem: Fin.predAbove_right_last
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [predAbove_of_castSucc_lt _ _ (castSucc_lt_last _), pred_last]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i.predAbove (last (n + 1)) = last n
state_after: no goals
Theorem: IsOpenMap.coverPreserving
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: constructor
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
⊢ CoverPreserving (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y) hf.functor
state_after: case cover_preserve
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
⊢ ∀ {U : Opens ↑X} {S : Sieve U},
    S ∈ (Opens.grothendieckTopology ↑X).sieves U →
      Sieve.functorPushforward hf.functor S ∈ (Opens.grothendieckTopology ↑Y).sieves (hf.functor.obj U)

tactic: rintro U S hU _ ⟨x, hx, rfl⟩
state_before: case cover_preserve
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
⊢ ∀ {U : Opens ↑X} {S : Sieve U},
    S ∈ (Opens.grothendieckTopology ↑X).sieves U →
      Sieve.functorPushforward hf.functor S ∈ (Opens.grothendieckTopology ↑Y).sieves (hf.functor.obj U)
state_after: case cover_preserve.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
U : Opens ↑X
S : Sieve U
hU : S ∈ (Opens.grothendieckTopology ↑X).sieves U
x : ↑X
hx : x ∈ ↑U
⊢ ∃ U_1 f_1, (Sieve.functorPushforward hf.functor S).arrows f_1 ∧ f x ∈ U_1

tactic: obtain ⟨V, i, hV, hxV⟩ := hU x hx
state_before: case cover_preserve.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
U : Opens ↑X
S : Sieve U
hU : S ∈ (Opens.grothendieckTopology ↑X).sieves U
x : ↑X
hx : x ∈ ↑U
⊢ ∃ U_1 f_1, (Sieve.functorPushforward hf.functor S).arrows f_1 ∧ f x ∈ U_1
state_after: case cover_preserve.intro.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
U : Opens ↑X
S : Sieve U
hU : S ∈ (Opens.grothendieckTopology ↑X).sieves U
x : ↑X
hx : x ∈ ↑U
V : Opens ↑X
i : V ⟶ U
hV : S.arrows i
hxV : x ∈ V
⊢ ∃ U_1 f_1, (Sieve.functorPushforward hf.functor S).arrows f_1 ∧ f x ∈ U_1

tactic: exact ⟨_, hf.functor.map i, ⟨_, i, 𝟙 _, hV, rfl⟩, Set.mem_image_of_mem f hxV⟩
state_before: case cover_preserve.intro.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : IsOpenMap ⇑f
U : Opens ↑X
S : Sieve U
hU : S ∈ (Opens.grothendieckTopology ↑X).sieves U
x : ↑X
hx : x ∈ ↑U
V : Opens ↑X
i : V ⟶ U
hV : S.arrows i
hxV : x ∈ V
⊢ ∃ U_1 f_1, (Sieve.functorPushforward hf.functor S).arrows f_1 ∧ f x ∈ U_1
state_after: no goals
Theorem: MeasurableEmbedding.id
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

tactic: rwa [image_id]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (_root_.id '' s)
state_after: no goals
Theorem: Real.Angle.two_nsmul_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: simp_rw [← natCast_zsmul, Nat.cast_ofNat, two_zsmul_eq_iff]
state_before: ψ θ : Angle
⊢ 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π
state_after: no goals
Theorem: Sym.exists_cons_of_mem
File: Mathlib/Data/Sym/Basic.lean

tactic: obtain ⟨m, h⟩ := Multiset.exists_cons_of_mem h
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h : a ∈ s
⊢ ∃ t, s = a ::ₛ t
state_after: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
⊢ ∃ t, s = a ::ₛ t

tactic: have : Multiset.card m = n := by
  apply_fun Multiset.card at h
  rw [s.2, Multiset.card_cons, add_left_inj] at h
  exact h.symm
state_before: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
⊢ ∃ t, s = a ::ₛ t
state_after: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ∃ t, s = a ::ₛ t

tactic: use ⟨m, this⟩
state_before: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ∃ t, s = a ::ₛ t
state_after: case h
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ s = a ::ₛ ⟨m, this⟩

tactic: apply Subtype.ext
state_before: case h
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ s = a ::ₛ ⟨m, this⟩
state_after: case h.a
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ↑s = ↑(a ::ₛ ⟨m, this⟩)

tactic: exact h
state_before: case h.a
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ↑s = ↑(a ::ₛ ⟨m, this⟩)
state_after: no goals

tactic: apply_fun Multiset.card at h
state_before: α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
⊢ Multiset.card m = n
state_after: α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : Multiset.card ↑s = Multiset.card (a ::ₘ m)
⊢ Multiset.card m = n

tactic: rw [s.2, Multiset.card_cons, add_left_inj] at h
state_before: α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : Multiset.card ↑s = Multiset.card (a ::ₘ m)
⊢ Multiset.card m = n
state_after: α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : n = Multiset.card m
⊢ Multiset.card m = n

tactic: exact h.symm
state_before: α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : n = Multiset.card m
⊢ Multiset.card m = n
state_after: no goals
Theorem: Homotopy.mkInductiveAux₃
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: subst j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
P Q : ChainComplex V ℕ
e : P ⟶ Q
zero : P.X 0 ⟶ Q.X 1
comm_zero : e.f 0 = zero ≫ Q.d 1 0
one : P.X 1 ⟶ Q.X 2
comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1
succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2)
i j : ℕ
h : i + 1 = j
⊢ (mkInductiveAux₂ e zero comm_zero one comm_one succ i).snd.fst ≫ (xPrevIso Q h).hom =
    (xNextIso P h).inv ≫ (mkInductiveAux₂ e zero comm_zero one comm_one succ j).fst
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
P Q : ChainComplex V ℕ
e : P ⟶ Q
zero : P.X 0 ⟶ Q.X 1
comm_zero : e.f 0 = zero ≫ Q.d 1 0
one : P.X 1 ⟶ Q.X 2
comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1
succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2)
i : ℕ
⊢ (mkInductiveAux₂ e zero comm_zero one comm_one succ i).snd.fst ≫ (xPrevIso Q ⋯).hom =
    (xNextIso P ⋯).inv ≫ (mkInductiveAux₂ e zero comm_zero one comm_one succ (i + 1)).fst

tactic: rcases i with (_ | _ | i) <;> simp [mkInductiveAux₂]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
P Q : ChainComplex V ℕ
e : P ⟶ Q
zero : P.X 0 ⟶ Q.X 1
comm_zero : e.f 0 = zero ≫ Q.d 1 0
one : P.X 1 ⟶ Q.X 2
comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1
succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2)
i : ℕ
⊢ (mkInductiveAux₂ e zero comm_zero one comm_one succ i).snd.fst ≫ (xPrevIso Q ⋯).hom =
    (xNextIso P ⋯).inv ≫ (mkInductiveAux₂ e zero comm_zero one comm_one succ (i + 1)).fst
state_after: no goals
Theorem: padicValNat_dvd_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
a : ℕ
⊢ p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a
state_after: case inl
p n : ℕ
hp : Fact (Nat.Prime p)
⊢ p ^ n ∣ 0 ↔ 0 = 0 ∨ n ≤ padicValNat p 0

case inr
p n : ℕ
hp : Fact (Nat.Prime p)
a : ℕ
ha : a ≠ 0
⊢ p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a

tactic: exact iff_of_true (dvd_zero _) (Or.inl rfl)
state_before: case inl
p n : ℕ
hp : Fact (Nat.Prime p)
⊢ p ^ n ∣ 0 ↔ 0 = 0 ∨ n ≤ padicValNat p 0
state_after: no goals

tactic: rw [padicValNat_dvd_iff_le ha, or_iff_right ha]
state_before: case inr
p n : ℕ
hp : Fact (Nat.Prime p)
a : ℕ
ha : a ≠ 0
⊢ p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a
state_after: no goals
Theorem: NNReal.le_mul_iInf
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [mul_iInf]
state_before: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), a ≤ g * h j
⊢ a ≤ g * iInf h
state_after: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), a ≤ g * h j
⊢ a ≤ ⨅ i, g * h i

tactic: exact le_ciInf H
state_before: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), a ≤ g * h j
⊢ a ≤ ⨅ i, g * h i
state_after: no goals
Theorem: Complex.cpow_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def]
state_before: x y : ℂ
⊢ x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
state_after: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0

tactic: split_ifs <;> simp [*, exp_ne_zero]
state_before: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0
state_after: no goals