1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_inv_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: rw [← cancel_epi (limitUncurryIsoLimitCompLim F).hom]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).inv ≫ limit.π (uncurry.obj F) (j, k) = limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ (limitUncurryIsoLimitCompLim F).inv ≫ limit.π (uncurry.obj F) (j, k) =
    (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ (limitUncurryIsoLimitCompLim F).inv ≫ limit.π (uncurry.obj F) (j, k) =
    (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k
state_after: no goals
Theorem: Multiset.countP_attach
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe, coe_countP]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (attach ⟦l⟧) = countP p ⟦l⟧
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (↑l).attach = List.countP (fun b => decide (p b)) l

tactic: rw [coe_attach]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (↑l).attach = List.countP (fun b => decide (p b)) l
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) ↑l.attach = List.countP (fun b => decide (p b)) l

tactic: refine (coe_countP _ _).trans ?_
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) ↑l.attach = List.countP (fun b => decide (p b)) l
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun b => decide (p b)) l

tactic: convert List.countP_attach _ _
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun b => decide (p b)) l
state_after: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun a => decide (p ↑a)) l.attach

tactic: rfl
state_before: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun a => decide (p ↑a)) l.attach
state_after: no goals
Theorem: CliffordAlgebra.evenOdd_map_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: simp_rw [evenOdd, Submodule.map_iSup, Submodule.map_pow, ι_range_map_involute]
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
⊢ Submodule.map involute.toLinearMap (evenOdd Q n) = evenOdd Q n
state_after: no goals
Theorem: Polynomial.leadingCoeff_neg
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [leadingCoeff, leadingCoeff, natDegree_neg, coeff_neg]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).leadingCoeff = -p.leadingCoeff
state_after: no goals
Theorem: Finset.prod_sdiff
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [← prod_union sdiff_disjoint, sdiff_union_of_subset h]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
⊢ (∏ x ∈ s₂ \ s₁, f x) * ∏ x ∈ s₁, f x = ∏ x ∈ s₂, f x
state_after: no goals
Theorem: Submonoid.closure_singleton_one
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: simp [eq_bot_iff_forall, mem_closure_singleton]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
⊢ closure {1} = ⊥
state_after: no goals
Theorem: intrinsicInterior_union_intrinsicFrontier
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: simp [intrinsicClosure, intrinsicInterior, intrinsicFrontier, closure_eq_interior_union_frontier,
  image_union]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s✝ t : Set P
x : P
s : Set P
⊢ intrinsicInterior 𝕜 s ∪ intrinsicFrontier 𝕜 s = intrinsicClosure 𝕜 s
state_after: no goals
Theorem: bit0_mul
File: Mathlib/Algebra/Order/Ring/Int.lean

tactic: rw [bit0, add_mul, ← one_add_one_eq_two, add_zsmul, one_zsmul]
state_before: R : Type u_1
inst✝ : NonUnitalNonAssocRing R
n r : R
⊢ bit0 n * r = 2 • (n * r)
state_after: no goals
Theorem: List.kerase_append_right
File: Mathlib/Data/List/Sigma.lean

tactic: simp only [keys_cons, mem_cons, not_or] at h
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h : a ∉ (head✝ :: l₁).keys
⊢ kerase a (head✝ :: l₁ ++ l₂) = head✝ :: l₁ ++ kerase a l₂
state_after: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h : ¬a = head✝.fst ∧ a ∉ l₁.keys
⊢ kerase a (head✝ :: l₁ ++ l₂) = head✝ :: l₁ ++ kerase a l₂

tactic: simp [h.1, kerase_append_right h.2]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h : ¬a = head✝.fst ∧ a ∉ l₁.keys
⊢ kerase a (head✝ :: l₁ ++ l₂) = head✝ :: l₁ ++ kerase a l₂
state_after: no goals
Theorem: CategoryTheory.Limits.kernelComparison_comp_kernel_map
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: rw [← G.map_comp, hpq, G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
state_after: no goals

tactic: rw [← G.map_comp, kernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f) ≫ G.map f = 0
state_after: no goals

tactic: rw [← G.map_comp, kernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι g) ≫ G.map g = 0
state_after: no goals

tactic: simp only [← G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f) ≫ G.map p = G.map (kernel.map f g p q hpq) ≫ G.map (kernel.ι g)
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f ≫ p) = G.map (kernel.map f g p q hpq ≫ kernel.ι g)

tactic: exact G.congr_map (kernel.lift_ι _ _ _).symm
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f ≫ p) = G.map (kernel.map f g p q hpq ≫ kernel.ι g)
state_after: no goals
Theorem: bit0_injective
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: dsimp [bit0] at h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : bit0 a = bit0 b
⊢ a = b
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : a + a = b + b
⊢ a = b

tactic: simp only [(two_mul a).symm, (two_mul b).symm] at h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : a + a = b + b
⊢ a = b
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ a = b

tactic: refine nat_mul_inj' ?_ two_ne_zero
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ a = b
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ ↑2 * a = ↑2 * b

tactic: exact mod_cast h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ ↑2 * a = ↑2 * b
state_after: no goals
Theorem: PiNat.firstDiff_le_longestPrefix
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rw [longestPrefix, le_tsub_iff_right]
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ firstDiff x y ≤ longestPrefix x s
state_after: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ firstDiff x y + 1 ≤ shortestPrefixDiff x s

E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ 1 ≤ shortestPrefixDiff x s

tactic: exact firstDiff_lt_shortestPrefixDiff hs hx hy
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ firstDiff x y + 1 ≤ shortestPrefixDiff x s
state_after: no goals

tactic: exact shortestPrefixDiff_pos hs ⟨y, hy⟩ hx
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ 1 ≤ shortestPrefixDiff x s
state_after: no goals
Theorem: Nat.succ_add_sub_one
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [succ_add, Nat.add_one_sub_one]
state_before: a b c d m✝ n✝ k : ℕ
p q : ℕ → Prop
n m : ℕ
⊢ m.succ + n - 1 = m + n
state_after: no goals
Theorem: Finset.singleton_inter_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, mem_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
H : a ∉ s
⊢ ∀ (x : α), x ∉ {a} ∩ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
H : a ∉ s
⊢ ∀ (x : α), ¬(x = a ∧ x ∈ s)

tactic: rintro x ⟨rfl, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
H : a ∉ s
⊢ ∀ (x : α), ¬(x = a ∧ x ∈ s)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x : α
h : x ∈ s
H : x ∉ s
⊢ False

tactic: exact H h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x : α
h : x ∈ s
H : x ∉ s
⊢ False
state_after: no goals
Theorem: EquicontinuousAt.closure'
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [← equicontinuousWithinAt_univ] at hA ⊢
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousAt (u ∘ Subtype.val) x₀
hu : Continuous u
⊢ EquicontinuousAt (u ∘ Subtype.val) x₀
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
hu : Continuous u
⊢ EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀

tactic: exact hA.closure' (Pi.continuous_restrict _ |>.comp hu) (continuous_apply x₀ |>.comp hu)
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
hu : Continuous u
⊢ EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
state_after: no goals
Theorem: Polynomial.mem_coeffs_iff
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp [coeffs, eq_comm, (Finset.mem_image)]
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
c : R
⊢ c ∈ p.coeffs ↔ ∃ n ∈ p.support, c = p.coeff n
state_after: no goals
Theorem: DFinsupp.Lex.acc_of_single_erase
File: Mathlib/Data/DFinsupp/WellFounded.lean

tactic: classical
  convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
    (InvImage.accessible snd <| hs.prod_gameAdd hu)
  convert piecewise_single_erase x i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (DFinsupp.Lex r s) (single i (x i))
hu : Acc (DFinsupp.Lex r s) (erase i x)
⊢ Acc (DFinsupp.Lex r s) x
state_after: no goals

tactic: convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
  (InvImage.accessible snd <| hs.prod_gameAdd hu)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (DFinsupp.Lex r s) (single i (x i))
hu : Acc (DFinsupp.Lex r s) (erase i x)
⊢ Acc (DFinsupp.Lex r s) x
state_after: case h.e'_3
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (DFinsupp.Lex r s) (single i (x i))
hu : Acc (DFinsupp.Lex r s) (erase i x)
⊢ ({i}, single i (x i), erase i x).2.1.piecewise ({i}, single i (x i), erase i x).2.2
      ({i}, single i (x i), erase i x).1 =
    x

tactic: convert piecewise_single_erase x i
state_before: case h.e'_3
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (DFinsupp.Lex r s) (single i (x i))
hu : Acc (DFinsupp.Lex r s) (erase i x)
⊢ ({i}, single i (x i), erase i x).2.1.piecewise ({i}, single i (x i), erase i x).2.2
      ({i}, single i (x i), erase i x).1 =
    x
state_after: no goals
Theorem: CategoryTheory.Grothendieck.id_fiber'
File: Mathlib/CategoryTheory/Grothendieck.lean

tactic: erw [CategoryTheory.Functor.map_id, Functor.id_obj X.fiber]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.17688, u_1} C
inst✝ : Category.{?u.17692, u_2} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (𝟙 X).base).obj X.fiber = X.fiber
state_after: no goals
Theorem: IsSquare.map
File: Mathlib/Algebra/Group/Even.lean

tactic: rintro ⟨m, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : α
f : F
⊢ IsSquare m → IsSquare (f m)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
m : α
⊢ IsSquare (f (m * m))

tactic: exact ⟨f m, by simp⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
m : α
⊢ IsSquare (f (m * m))
state_after: no goals

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
m : α
⊢ f (m * m) = f m * f m
state_after: no goals
Theorem: Nat.factorization_eq_of_coprime_right
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [mul_comm]
state_before: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.factors
⊢ (a * b).factorization p = b.factorization p
state_after: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.factors
⊢ (b * a).factorization p = b.factorization p

tactic: exact factorization_eq_of_coprime_left (coprime_comm.mp hab) hpb
state_before: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.factors
⊢ (b * a).factorization p = b.factorization p
state_after: no goals
Theorem: Function.mulSupport_one_sub'
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

tactic: rw [sub_eq_add_neg, mulSupport_one_add', support_neg']
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝¹ : One R
inst✝ : AddGroup R
f : ι → R
⊢ mulSupport (1 - f) = support f
state_after: no goals
Theorem: re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [@norm_add_mul_self 𝕜, @norm_sub_mul_self 𝕜]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖ - (‖x‖ * ‖x‖ - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖)) / 4

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖ - (‖x‖ * ‖x‖ - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖)) / 4
state_after: no goals
Theorem: Real.continuousAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: rw [le_iff_lt_or_eq, ← or_assoc] at h
state_before: x q : ℝ
h : x ≠ 0 ∨ 0 ≤ q
⊢ ContinuousAt (fun x => x ^ q) x
state_after: x q : ℝ
h : (x ≠ 0 ∨ 0 < q) ∨ 0 = q
⊢ ContinuousAt (fun x => x ^ q) x

tactic: obtain h|rfl := h
state_before: x q : ℝ
h : (x ≠ 0 ∨ 0 < q) ∨ 0 = q
⊢ ContinuousAt (fun x => x ^ q) x
state_after: case inl
x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt (fun x => x ^ q) x

case inr
x : ℝ
⊢ ContinuousAt (fun x => x ^ 0) x

tactic: exact (continuousAt_rpow (x, q) h).comp₂ continuousAt_id continuousAt_const
state_before: case inl
x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt (fun x => x ^ q) x
state_after: no goals

tactic: simp_rw [rpow_zero]
state_before: case inr
x : ℝ
⊢ ContinuousAt (fun x => x ^ 0) x
state_after: case inr
x : ℝ
⊢ ContinuousAt (fun x => 1) x

tactic: exact continuousAt_const
state_before: case inr
x : ℝ
⊢ ContinuousAt (fun x => 1) x
state_after: no goals
Theorem: EReal.preimage_coe_Ioo
File: Mathlib/Data/Real/EReal.lean

tactic: simp_rw [← Ioi_inter_Iio]
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' Ioo ↑x ↑y = Ioo x y
state_after: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iio ↑y) = Ioi x ∩ Iio y

tactic: simp
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iio ↑y) = Ioi x ∩ Iio y
state_after: no goals
Theorem: Padic.AddValuation.map_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [addValuationDef, if_neg one_ne_zero, valuation_one, WithTop.coe_zero]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ addValuationDef 1 = 0
state_after: no goals
Theorem: HahnSeries.BddBelow_zero
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: simp only [support_zero', bddBelow_empty]
state_before: Γ : Type u_1
R : Type u_2
inst✝³ : Zero R
inst✝² : LinearOrder Γ
inst✝¹ : LocallyFiniteOrder Γ
inst✝ : Nonempty Γ
⊢ BddBelow (Function.support 0)
state_after: no goals
Theorem: Nat.chineseRemainder_modEq_unique
File: Mathlib/Data/Nat/ModEq.lean

tactic: simpa [Nat.Coprime.lcm_eq_mul co] using
  mod_lcm (hzan.trans ((chineseRemainder co a b).prop.1).symm)
    (hzbm.trans ((chineseRemainder co a b).prop.2).symm)
state_before: m n a✝ b✝ c d : ℕ
co : n.Coprime m
a b z : ℕ
hzan : z ≡ a [MOD n]
hzbm : z ≡ b [MOD m]
⊢ z ≡ ↑(chineseRemainder co a b) [MOD n * m]
state_after: no goals
Theorem: Set.image2_eq_empty_iff
File: Mathlib/Data/Set/NAry.lean

tactic: rw [← not_nonempty_iff_eq_empty, image2_nonempty_iff, not_and_or]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s t = ∅ ↔ s = ∅ ∨ t = ∅
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ¬s.Nonempty ∨ ¬t.Nonempty ↔ s = ∅ ∨ t = ∅

tactic: simp [not_nonempty_iff_eq_empty]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ¬s.Nonempty ∨ ¬t.Nonempty ↔ s = ∅ ∨ t = ∅
state_after: no goals