1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.invOf_diagonal_eq
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := diagonalInvertible v
state_before: l : Type u_1
m : Type u
n : Type u'
α✝ : Type v
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α✝
A B : Matrix n n α✝
α : Type u_2
inst✝² : Semiring α
v : n → α
inst✝¹ : Invertible v
inst✝ : Invertible (diagonal v)
⊢ ⅟(diagonal v) = diagonal ⅟v
state_after: l : Type u_1
m : Type u
n : Type u'
α✝ : Type v
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α✝
A B : Matrix n n α✝
α : Type u_2
inst✝² : Semiring α
v : n → α
inst✝¹ : Invertible v
inst✝ : Invertible (diagonal v)
this : Invertible (diagonal v) := diagonalInvertible v
⊢ ⅟(diagonal v) = diagonal ⅟v

tactic: convert (rfl : ⅟ (diagonal v) = _)
state_before: l : Type u_1
m : Type u
n : Type u'
α✝ : Type v
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α✝
A B : Matrix n n α✝
α : Type u_2
inst✝² : Semiring α
v : n → α
inst✝¹ : Invertible v
inst✝ : Invertible (diagonal v)
this : Invertible (diagonal v) := diagonalInvertible v
⊢ ⅟(diagonal v) = diagonal ⅟v
state_after: no goals
Theorem: upperCentralSeries_one
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: ext
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
⊢ upperCentralSeries G 1 = center G
state_after: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
x✝ : G
⊢ x✝ ∈ upperCentralSeries G 1 ↔ x✝ ∈ center G

tactic: simp only [upperCentralSeries, upperCentralSeriesAux, upperCentralSeriesStep,
  Subgroup.mem_center_iff, mem_mk, mem_bot, Set.mem_setOf_eq]
state_before: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
x✝ : G
⊢ x✝ ∈ upperCentralSeries G 1 ↔ x✝ ∈ center G
state_after: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
x✝ : G
⊢ (∀ (y : G), x✝ * y * x✝⁻¹ * y⁻¹ = 1) ↔ ∀ (g : G), g * x✝ = x✝ * g

tactic: exact forall_congr' fun y => by rw [mul_inv_eq_one, mul_inv_eq_iff_eq_mul, eq_comm]
state_before: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
x✝ : G
⊢ (∀ (y : G), x✝ * y * x✝⁻¹ * y⁻¹ = 1) ↔ ∀ (g : G), g * x✝ = x✝ * g
state_after: no goals

tactic: rw [mul_inv_eq_one, mul_inv_eq_iff_eq_mul, eq_comm]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
x✝ y : G
⊢ x✝ * y * x✝⁻¹ * y⁻¹ = 1 ↔ y * x✝ = x✝ * y
state_after: no goals
Theorem: List.range'_concat
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [Nat.add_comm n 1]
state_before: step s n : Nat
⊢ range' s (n + 1) step = range' s n step ++ [s + step * n]
state_after: step s n : Nat
⊢ range' s (1 + n) step = range' s n step ++ [s + step * n]

tactic: exact (range'_append s n 1 step).symm
state_before: step s n : Nat
⊢ range' s (1 + n) step = range' s n step ++ [s + step * n]
state_after: no goals
Theorem: NumberField.InfinitePlace.not_isUnramified_iff_card_stabilizer_eq_two
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [isUnramified_iff_card_stabilizer_eq_one]
state_before: k : Type u_1
inst✝⁸ : Field k
K : Type u_2
inst✝⁷ : Field K
F : Type u_3
inst✝⁶ : Field F
inst✝⁵ : NumberField K
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
inst✝ : IsGalois k K
⊢ ¬IsUnramified k w ↔ Nat.card ↥(Stab w) = 2
state_after: k : Type u_1
inst✝⁸ : Field k
K : Type u_2
inst✝⁷ : Field K
F : Type u_3
inst✝⁶ : Field F
inst✝⁵ : NumberField K
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
inst✝ : IsGalois k K
⊢ ¬Nat.card ↥(Stab w) = 1 ↔ Nat.card ↥(Stab w) = 2

tactic: obtain (e|e) := nat_card_stabilizer_eq_one_or_two k w <;> rw [e] <;> decide
state_before: k : Type u_1
inst✝⁸ : Field k
K : Type u_2
inst✝⁷ : Field K
F : Type u_3
inst✝⁶ : Field F
inst✝⁵ : NumberField K
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
inst✝ : IsGalois k K
⊢ ¬Nat.card ↥(Stab w) = 1 ↔ Nat.card ↥(Stab w) = 2
state_after: no goals
Theorem: Int.modEq_zero_iff_dvd
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [ModEq, zero_emod, dvd_iff_emod_eq_zero]
state_before: m n a b c d : ℤ
⊢ a ≡ 0 [ZMOD n] ↔ n ∣ a
state_after: no goals
Theorem: Filter.Germ.const_max
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: rw [max_def, map₂_const]
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : LinearOrder β
x y : β
⊢ ↑(max x y) = max ↑x ↑y
state_after: no goals
Theorem: Finset.erase_biUnion
File: Mathlib/Data/Finset/Union.lean

tactic: ext a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
f : α → Finset β
s : Finset α
b : β
⊢ (s.biUnion f).erase b = s.biUnion fun x => (f x).erase b
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
f : α → Finset β
s : Finset α
b a : β
⊢ a ∈ (s.biUnion f).erase b ↔ a ∈ s.biUnion fun x => (f x).erase b

tactic: simp only [mem_biUnion, not_exists, not_and, mem_erase, ne_eq]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
f : α → Finset β
s : Finset α
b a : β
⊢ a ∈ (s.biUnion f).erase b ↔ a ∈ s.biUnion fun x => (f x).erase b
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
f : α → Finset β
s : Finset α
b a : β
⊢ (¬a = b ∧ ∃ a_1 ∈ s, a ∈ f a_1) ↔ ∃ a_1 ∈ s, ¬a = b ∧ a ∈ f a_1

tactic: tauto
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
f : α → Finset β
s : Finset α
b a : β
⊢ (¬a = b ∧ ∃ a_1 ∈ s, a ∈ f a_1) ↔ ∃ a_1 ∈ s, ¬a = b ∧ a ∈ f a_1
state_after: no goals
Theorem: List.get?_modifyNth
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [getElem?_modifyNth]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
m : Nat
⊢ (modifyNth f n l).get? m = (fun a => if n = m then f a else a) <$> l.get? m
state_after: no goals
Theorem: String.any_iff
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [any_eq]
state_before: s : String
p : Char → Bool
⊢ s.any p = true ↔ ∃ c, c ∈ s.data ∧ p c = true
state_after: no goals
Theorem: Nat.greatestFib_sub_fib_greatestFib_le_greatestFib
File: Mathlib/Data/Nat/Fib/Zeckendorf.lean

tactic: rw [← Nat.lt_succ_iff, greatestFib_lt, tsub_lt_iff_right n.fib_greatestFib_le, Nat.sub_succ,
  succ_pred, ← fib_add_one]
state_before: l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ (n - fib n.greatestFib).greatestFib ≤ n.greatestFib - 2
state_after: l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n < fib (n.greatestFib + 1)

l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n.greatestFib ≠ 0

l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n.greatestFib - 1 ≠ 0

tactic: exact n.lt_fib_greatestFib_add_one
state_before: l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n < fib (n.greatestFib + 1)
state_after: no goals

tactic: simpa
state_before: l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n.greatestFib ≠ 0
state_after: no goals

tactic: simpa [← succ_le_iff, tsub_eq_zero_iff_le] using hn.bot_lt
state_before: l : List ℕ
a m n : ℕ
hn : n ≠ 0
⊢ n.greatestFib - 1 ≠ 0
state_after: no goals
Theorem: Function.Embedding.equiv_toEmbedding_trans_symm_toEmbedding
File: Mathlib/Logic/Embedding/Basic.lean

tactic: ext
state_before: α : Sort u_1
β : Sort u_2
e : α ≃ β
⊢ e.toEmbedding.trans e.symm.toEmbedding = Embedding.refl α
state_after: case h
α : Sort u_1
β : Sort u_2
e : α ≃ β
x✝ : α
⊢ (e.toEmbedding.trans e.symm.toEmbedding) x✝ = (Embedding.refl α) x✝

tactic: simp
state_before: case h
α : Sort u_1
β : Sort u_2
e : α ≃ β
x✝ : α
⊢ (e.toEmbedding.trans e.symm.toEmbedding) x✝ = (Embedding.refl α) x✝
state_after: no goals
Theorem: rootsOfUnity.coe_pow
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [Subgroup.coe_pow, Units.val_pow_eq_pow_val]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ+
inst✝ : CommMonoid R
ζ : ↥(rootsOfUnity k R)
m : ℕ
⊢ ↑↑(ζ ^ m) = ↑↑ζ ^ m
state_after: no goals
Theorem: ENNReal.iSup_add_iSup_le
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp_rw [iSup_add, add_iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
ι' : Sort u_5
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι) (j : ι'), f i + g j ≤ a
⊢ iSup f + iSup g ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
ι' : Sort u_5
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι) (j : ι'), f i + g j ≤ a
⊢ ⨆ b, ⨆ b_1, f b + g b_1 ≤ a

tactic: exact iSup₂_le h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
ι' : Sort u_5
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι) (j : ι'), f i + g j ≤ a
⊢ ⨆ b, ⨆ b_1, f b + g b_1 ≤ a
state_after: no goals
Theorem: IsPrimitiveRoot.card_nthRoots_one
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [card_nthRoots h, if_pos ⟨ζ, h.pow_eq_one⟩]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ Multiset.card (nthRoots n 1) = n
state_after: no goals
Theorem: isNoetherian_of_range_eq_ker
File: Mathlib/RingTheory/Noetherian.lean

tactic: simp [Submodule.map_comap_eq, inf_comm, Submodule.range_liftQ]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : IsNoetherian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N),
    Submodule.map ((LinearMap.ker f).liftQ f ⋯) (Submodule.comap ((LinearMap.ker f).liftQ f ⋯) a) =
      a ⊓ LinearMap.range f
state_after: no goals

tactic: simp [Submodule.comap_map_eq, h]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : IsNoetherian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N), Submodule.comap g.rangeRestrict (Submodule.map g.rangeRestrict a) = a ⊔ LinearMap.range f
state_after: no goals
Theorem: TopCat.Presheaf.pushforward_eq'_hom_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: rw [h]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (Opens.map f).op.obj U = (Opens.map g).op.obj U
state_after: no goals

tactic: rw [eqToHom_app, eqToHom_map]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (eqToHom ⋯).app U = ℱ.map (eqToHom ⋯)
state_after: no goals
Theorem: isCoprime_self
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rwa [mul_comm, add_mul]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
x✝ : IsCoprime x x
a b : R
h : a * x + b * x = 1
⊢ x * (a + b) = 1
state_after: no goals

tactic: rwa [zero_mul, add_zero]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsUnit x
b : R
hb : b * x = 1
⊢ b * x + 0 * x = 1
state_after: no goals
Theorem: iSup_image
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← sSup_image, ← sSup_image, ← image_comp]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ✝ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g✝ s t✝ : ι → α
a b : α
γ : Type u_9
f : β → γ
g : γ → α
t : Set β
⊢ ⨆ c ∈ f '' t, g c = ⨆ b ∈ t, g (f b)
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ✝ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g✝ s t✝ : ι → α
a b : α
γ : Type u_9
f : β → γ
g : γ → α
t : Set β
⊢ sSup (g ∘ f '' t) = sSup ((fun b => g (f b)) '' t)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ✝ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g✝ s t✝ : ι → α
a b : α
γ : Type u_9
f : β → γ
g : γ → α
t : Set β
⊢ sSup (g ∘ f '' t) = sSup ((fun b => g (f b)) '' t)
state_after: no goals
Theorem: Batteries.UnionFind.parent_rootD
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: rw [rootD]
state_before: self : UnionFind
x : Nat
⊢ self.parent (self.rootD x) = self.rootD x
state_after: self : UnionFind
x : Nat
⊢ self.parent (if h : x < self.size then ↑(self.root ⟨x, h⟩) else x) =
    if h : x < self.size then ↑(self.root ⟨x, h⟩) else x

tactic: split <;>
[simp [parentD, parent_root, -Array.get_eq_getElem]; simp [parentD_of_not_lt, *]]
state_before: self : UnionFind
x : Nat
⊢ self.parent (if h : x < self.size then ↑(self.root ⟨x, h⟩) else x) =
    if h : x < self.size then ↑(self.root ⟨x, h⟩) else x
state_after: no goals
Theorem: AdjoinRoot.mk_eq_zero
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [sub_zero]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f g : R[X]
⊢ f ∣ g - 0 ↔ f ∣ g
state_after: no goals
Theorem: Matrix.det_updateColumn_smul'
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [← det_transpose, ← updateRow_transpose, transpose_smul, det_updateRow_smul']
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ ((s • M).updateColumn j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s ^ (Fintype.card n - 1) * (Mᵀ.updateRow j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det

tactic: simp [updateRow_transpose, det_transpose]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s ^ (Fintype.card n - 1) * (Mᵀ.updateRow j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det
state_after: no goals
Theorem: ValuationSubring.image_maximalIdeal
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: ext a
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
⊢ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) = ↑A.nonunits
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ a ∈ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) ↔ a ∈ ↑A.nonunits

tactic: simp only [Set.mem_image, SetLike.mem_coe, mem_nonunits_iff_exists_mem_maximalIdeal]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ a ∈ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) ↔ a ∈ ↑A.nonunits
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ x ∈ LocalRing.maximalIdeal ↥A, ↑x = a) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A

tactic: erw [Subtype.exists]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ x ∈ LocalRing.maximalIdeal ↥A, ↑x = a) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ a_1, ∃ (b : a_1 ∈ ↑A), ⟨a_1, b⟩ ∈ LocalRing.maximalIdeal ↥A ∧ ↑⟨a_1, b⟩ = a) ↔
    ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A

tactic: simp_rw [exists_and_right, exists_eq_right]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ a_1, ∃ (b : a_1 ∈ ↑A), ⟨a_1, b⟩ ∈ LocalRing.maximalIdeal ↥A ∧ ↑⟨a_1, b⟩ = a) ↔
    ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ (x : a ∈ ↑A), ⟨a, ⋯⟩ ∈ LocalRing.maximalIdeal ↥A) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A

tactic: simp
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ (x : a ∈ ↑A), ⟨a, ⋯⟩ ∈ LocalRing.maximalIdeal ↥A) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: no goals
Theorem: Real.nnnorm_two
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ ↑‖2‖₊ = ↑2
state_after: no goals
Theorem: Polynomial.degree_eq_card_roots'
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: simp [degree_eq_natDegree p_ne_zero, natDegree_eq_card_roots' hsplit]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i✝ : K →+* L
p : K[X]
i : K →+* L
p_ne_zero : map i p ≠ 0
hsplit : Splits i p
⊢ (map i p).degree = ↑(Multiset.card (map i p).roots)
state_after: no goals
Theorem: dimH_countable
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: simp only [dimH_bUnion hs, dimH_singleton, ENNReal.iSup_zero_eq_zero]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
hs : s.Countable
⊢ dimH (⋃ x ∈ s, {x}) = 0
state_after: no goals
Theorem: tendsto_ceil_left_pure
File: Mathlib/Topology/Algebra/Order/Floor.lean

tactic: simpa only [ceil_intCast] using tendsto_ceil_left_pure_ceil (n : α)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ Tendsto ceil (𝓝[≤] ↑n) (pure n)
state_after: no goals
Theorem: ENNReal.lt_rpow_one_div_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: nth_rw 1 [← rpow_one x]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x < y ^ (1 / z) ↔ x ^ z < y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 < y ^ (1 / z) ↔ x ^ z < y

tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z (ne_of_lt hz).symm]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 < y ^ (1 / z) ↔ x ^ z < y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) < y ^ (1 / z) ↔ x ^ z < y

tactic: rw [rpow_mul, ← one_div, @rpow_lt_rpow_iff _ _ (1 / z) (by simp [hz])]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) < y ^ (1 / z) ↔ x ^ z < y
state_after: no goals

tactic: simp [hz]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ 0 < 1 / z
state_after: no goals
Theorem: IsCoprime.of_mul_add_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm] at h
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (x * z + y)
⊢ IsCoprime x y
state_after: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + x * z)
⊢ IsCoprime x y

tactic: exact h.of_add_mul_left_right
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + x * z)
⊢ IsCoprime x y
state_after: no goals
Theorem: Ordinal.div_nonempty
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [succ_zero, one_mul] using
  mul_le_mul_right' (succ_le_of_lt (Ordinal.pos_iff_ne_zero.2 h)) (succ a)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : b ≠ 0
⊢ succ a ≤ b * succ a
state_after: no goals
Theorem: lawful_beq_subsingleton
File: Mathlib/Logic/Basic.lean

tactic: apply beq_ext
state_before: α : Type u_1
inst1 inst2 : BEq α
inst✝¹ : LawfulBEq α
inst✝ : LawfulBEq α
⊢ inst1 = inst2
state_after: case h
α : Type u_1
inst1 inst2 : BEq α
inst✝¹ : LawfulBEq α
inst✝ : LawfulBEq α
⊢ ∀ (x y : α), (x == y) = (x == y)

tactic: intro x y
state_before: case h
α : Type u_1
inst1 inst2 : BEq α
inst✝¹ : LawfulBEq α
inst✝ : LawfulBEq α
⊢ ∀ (x y : α), (x == y) = (x == y)
state_after: case h
α : Type u_1
inst1 inst2 : BEq α
inst✝¹ : LawfulBEq α
inst✝ : LawfulBEq α
x y : α
⊢ (x == y) = (x == y)

tactic: simp only [beq_eq_decide]
state_before: case h
α : Type u_1
inst1 inst2 : BEq α
inst✝¹ : LawfulBEq α
inst✝ : LawfulBEq α
x y : α
⊢ (x == y) = (x == y)
state_after: no goals
Theorem: Matrix.smul_vec2
File: Mathlib/Data/Matrix/Notation.lean

tactic: rw [smul_cons, smul_cons, smul_empty]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
R : Type u_1
inst✝ : SMul R α
x : R
a₀ a₁ : α
⊢ x • ![a₀, a₁] = ![x • a₀, x • a₁]
state_after: no goals
Theorem: support_comp_inv_smul₀
File: Mathlib/Data/Set/Pointwise/Support.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
inst✝ : Zero γ
c : α
hc : c ≠ 0
f : β → γ
⊢ (support fun x => f (c⁻¹ • x)) = c • support f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
inst✝ : Zero γ
c : α
hc : c ≠ 0
f : β → γ
x : β
⊢ (x ∈ support fun x => f (c⁻¹ • x)) ↔ x ∈ c • support f

tactic: simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_support]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
inst✝ : Zero γ
c : α
hc : c ≠ 0
f : β → γ
x : β
⊢ (x ∈ support fun x => f (c⁻¹ • x)) ↔ x ∈ c • support f
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.LeftFractionRel.unop
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: obtain ⟨Z, t₁, t₂, hs, hf, ht⟩ := h
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.133960, u_2} D
L : C ⥤ D
W✝ : MorphismProperty C
inst✝ : L.IsLocalization W✝
W : MorphismProperty Cᵒᵖ
X Y : Cᵒᵖ
z₁ z₂ : W.LeftFraction X Y
h : LeftFractionRel z₁ z₂
⊢ RightFractionRel z₁.unop z₂.unop
state_after: case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.133960, u_2} D
L : C ⥤ D
W✝ : MorphismProperty C
inst✝ : L.IsLocalization W✝
W : MorphismProperty Cᵒᵖ
X Y : Cᵒᵖ
z₁ z₂ : W.LeftFraction X Y
Z : Cᵒᵖ
t₁ : z₁.Y' ⟶ Z
t₂ : z₂.Y' ⟶ Z
hs : z₁.s ≫ t₁ = z₂.s ≫ t₂
hf : z₁.f ≫ t₁ = z₂.f ≫ t₂
ht : W (z₁.s ≫ t₁)
⊢ RightFractionRel z₁.unop z₂.unop

tactic: exact ⟨Opposite.unop Z, t₁.unop, t₂.unop, Quiver.Hom.op_inj hs,
  Quiver.Hom.op_inj hf, ht⟩
state_before: case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.133960, u_2} D
L : C ⥤ D
W✝ : MorphismProperty C
inst✝ : L.IsLocalization W✝
W : MorphismProperty Cᵒᵖ
X Y : Cᵒᵖ
z₁ z₂ : W.LeftFraction X Y
Z : Cᵒᵖ
t₁ : z₁.Y' ⟶ Z
t₂ : z₂.Y' ⟶ Z
hs : z₁.s ≫ t₁ = z₂.s ≫ t₂
hf : z₁.f ≫ t₁ = z₂.f ≫ t₂
ht : W (z₁.s ≫ t₁)
⊢ RightFractionRel z₁.unop z₂.unop
state_after: no goals