1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.univ_pow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [coe_pow, coe_univ, Set.univ_pow hn]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : Monoid α
s t : Finset α
a : α
m n : ℕ
inst✝ : Fintype α
hn : n ≠ 0
⊢ ↑(univ ^ n) = ↑univ
state_after: no goals
Theorem: AlgebraicGeometry.quasiSeparated_eq_affineProperty
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

tactic: rw [quasiSeparated_eq_affineProperty_diagonal, quasi_compact_affineProperty_diagonal_eq]
state_before: X Y : Scheme
f : X ⟶ Y
⊢ @QuasiSeparated = targetAffineLocally QuasiSeparated.affineProperty
state_after: no goals
Theorem: Mathlib.Tactic.Abel.subst_into_smul
File: Mathlib/Tactic/Abel.lean

tactic: simp [prl, prr, prt]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
l : ℕ
r : α
tl : ℕ
tr t : α
prl : l = tl
prr : r = tr
prt : smul tl tr = t
⊢ smul l r = t
state_after: no goals
Theorem: Filter.prod_neBot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [neBot_iff, Ne, prod_eq_bot, not_or]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
⊢ (f ×ˢ g).NeBot ↔ f.NeBot ∧ g.NeBot
state_after: no goals
Theorem: Orientation.norm_div_tan_oangle_sub_right_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: have hs : (o.oangle y (y - x)).sign = 1 := by
  rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle y (y - x)).sign = 1
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖y‖

tactic: rw [o.oangle_eq_angle_of_sign_eq_one hs, Real.Angle.tan_coe,
  InnerProductGeometry.norm_div_tan_angle_sub_of_inner_eq_zero
    (o.inner_rev_eq_zero_of_oangle_eq_pi_div_two h)
    (Or.inr (o.left_ne_zero_of_oangle_eq_pi_div_two h))]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle y (y - x)).sign = 1
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖y‖
state_after: no goals

tactic: rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle y (y - x)).sign = 1
state_after: no goals
Theorem: LieModule.coe_weightSpace_of_top
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: ext m
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
⊢ ↑(weightSpace M (χ ∘ ⇑⊤.incl)) = ↑(weightSpace M χ)
state_after: case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ m ∈ ↑(weightSpace M (χ ∘ ⇑⊤.incl)) ↔ m ∈ ↑(weightSpace M χ)

tactic: simp only [mem_weightSpace, LieSubmodule.mem_coeSubmodule, Subtype.forall]
state_before: case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ m ∈ ↑(weightSpace M (χ ∘ ⇑⊤.incl)) ↔ m ∈ ↑(weightSpace M χ)
state_after: case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ (∀ (a : L) (b : a ∈ ⊤), ∃ k, (((toEnd R (↥⊤) M) ⟨a, b⟩ - (χ ∘ ⇑⊤.incl) ⟨a, b⟩ • 1) ^ k) m = 0) ↔
    ∀ (x : L), ∃ k, (((toEnd R L M) x - χ x • 1) ^ k) m = 0

tactic: apply forall_congr'
state_before: case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ (∀ (a : L) (b : a ∈ ⊤), ∃ k, (((toEnd R (↥⊤) M) ⟨a, b⟩ - (χ ∘ ⇑⊤.incl) ⟨a, b⟩ • 1) ^ k) m = 0) ↔
    ∀ (x : L), ∃ k, (((toEnd R L M) x - χ x • 1) ^ k) m = 0
state_after: case h.h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ ∀ (a : L),
    (∀ (b : a ∈ ⊤), ∃ k, (((toEnd R (↥⊤) M) ⟨a, b⟩ - (χ ∘ ⇑⊤.incl) ⟨a, b⟩ • 1) ^ k) m = 0) ↔
      ∃ k, (((toEnd R L M) a - χ a • 1) ^ k) m = 0

tactic: simp
state_before: case h.h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ ∀ (a : L),
    (∀ (b : a ∈ ⊤), ∃ k, (((toEnd R (↥⊤) M) ⟨a, b⟩ - (χ ∘ ⇑⊤.incl) ⟨a, b⟩ • 1) ^ k) m = 0) ↔
      ∃ k, (((toEnd R L M) a - χ a • 1) ^ k) m = 0
state_after: no goals
Theorem: Nat.two_le_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: simp
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ 2 ≤ 0 ↔ 0 ≠ 0 ∧ 0 ≠ 1
state_after: no goals

tactic: simp
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ 2 ≤ 1 ↔ 1 ≠ 0 ∧ 1 ≠ 1
state_after: no goals

tactic: simp
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ 2 ≤ n + 2 ↔ n + 2 ≠ 0 ∧ n + 2 ≠ 1
state_after: no goals
Theorem: SimpleGraph.Walk.edges_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [edges, List.map_reverse]
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.reverse.edges = p.edges.reverse
state_after: no goals
Theorem: Matrix.eval_charpolyRev
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: rw [charpolyRev, ← coe_evalRingHom, RingHom.map_det, ← det_one (R := R) (n := n)]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ eval 0 M.charpolyRev = 1
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1

tactic: have : (1 - (X : R[X]) • M.map C).map (eval 0) = 1 := by
  ext i j; rcases eq_or_ne i j with hij | hij <;> simp [hij, one_apply]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
this : (1 - X • M.map ⇑C).map (eval 0) = 1
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1

tactic: congr
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
this : (1 - X • M.map ⇑C).map (eval 0) = 1
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
state_after: no goals

tactic: ext i j
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ (1 - X • M.map ⇑C).map (eval 0) = 1
state_after: case a
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
i j : n
⊢ (1 - X • M.map ⇑C).map (eval 0) i j = 1 i j

tactic: rcases eq_or_ne i j with hij | hij <;> simp [hij, one_apply]
state_before: case a
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
i j : n
⊢ (1 - X • M.map ⇑C).map (eval 0) i j = 1 i j
state_after: no goals
Theorem: mem_closure_iff_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [mem_closure_iff_nhds_basis ((𝓝 1 : Filter G).basis_sets.nhds_of_one x)]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ x ∈ closure s ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ (∀ i ∈ 𝓝 1, ∃ y ∈ s, y ∈ {y | y / x ∈ id i}) ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U

tactic: simp_rw [Set.mem_setOf, id]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ (∀ i ∈ 𝓝 1, ∃ y ∈ s, y ∈ {y | y / x ∈ id i}) ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U
state_after: no goals
Theorem: algebraicIndependent_subtype
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: apply @algebraicIndependent_comp_subtype _ _ _ id
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
s : Set A
⊢ AlgebraicIndependent R Subtype.val ↔ ∀ p ∈ supported R s, (aeval _root_.id) p = 0 → p = 0
state_after: no goals
Theorem: LieSubmodule.trivial_lie_oper_zero
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: suffices ⁅I, N⁆ ≤ ⊥ from le_bot_iff.mp this
state_before: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ = ⊥
state_after: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ ≤ ⊥

tactic: rw [lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ ≤ ⊥
state_after: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑⊥

tactic: rintro m ⟨x, n, h⟩
state_before: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑⊥
state_after: case intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : ↥I
n : ↥N
h : ⁅↑x, ↑n⁆ = m
⊢ m ∈ ↑⊥

tactic: rw [trivial_lie_zero] at h
state_before: case intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : ↥I
n : ↥N
h : ⁅↑x, ↑n⁆ = m
⊢ m ∈ ↑⊥
state_after: case intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : ↥I
n : ↥N
h : 0 = m
⊢ m ∈ ↑⊥

tactic: simp [← h]
state_before: case intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : ↥I
n : ↥N
h : 0 = m
⊢ m ∈ ↑⊥
state_after: no goals
Theorem: Basis.orientation_eq_or_eq_neg
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: induction' x using Module.Ray.ind with x hx
state_before: R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : Orientation R M ι
⊢ x = e.orientation ∨ x = -e.orientation
state_after: case h
R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : M [⋀^ι]→ₗ[R] R
hx : x ≠ 0
⊢ rayOfNeZero R x hx = e.orientation ∨ rayOfNeZero R x hx = -e.orientation

tactic: rw [← x.map_basis_ne_zero_iff e] at hx
state_before: case h
R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : M [⋀^ι]→ₗ[R] R
hx : x ≠ 0
⊢ rayOfNeZero R x hx = e.orientation ∨ rayOfNeZero R x hx = -e.orientation
state_after: case h
R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : M [⋀^ι]→ₗ[R] R
hx✝ : x ≠ 0
hx : x ⇑e ≠ 0
⊢ rayOfNeZero R x hx✝ = e.orientation ∨ rayOfNeZero R x hx✝ = -e.orientation

tactic: rwa [Basis.orientation, ray_eq_iff, neg_rayOfNeZero, ray_eq_iff, x.eq_smul_basis_det e,
  sameRay_neg_smul_left_iff_of_ne e.det_ne_zero hx, sameRay_smul_left_iff_of_ne e.det_ne_zero hx,
  lt_or_lt_iff_ne, ne_comm]
state_before: case h
R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : M [⋀^ι]→ₗ[R] R
hx✝ : x ≠ 0
hx : x ⇑e ≠ 0
⊢ rayOfNeZero R x hx✝ = e.orientation ∨ rayOfNeZero R x hx✝ = -e.orientation
state_after: no goals
Theorem: ArithmeticFunction.vonMangoldt_nonneg
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: rw [vonMangoldt_apply]
state_before: n : ℕ
⊢ 0 ≤ Λ n
state_after: n : ℕ
⊢ 0 ≤ if IsPrimePow n then Real.log ↑n.minFac else 0

tactic: split_ifs
state_before: n : ℕ
⊢ 0 ≤ if IsPrimePow n then Real.log ↑n.minFac else 0
state_after: case pos
n : ℕ
h✝ : IsPrimePow n
⊢ 0 ≤ Real.log ↑n.minFac

case neg
n : ℕ
h✝ : ¬IsPrimePow n
⊢ 0 ≤ 0

tactic: rfl
state_before: case neg
n : ℕ
h✝ : ¬IsPrimePow n
⊢ 0 ≤ 0
state_after: no goals

tactic: exact Real.log_nonneg (one_le_cast.2 (Nat.minFac_pos n))
state_before: case pos
n : ℕ
h✝ : IsPrimePow n
⊢ 0 ≤ Real.log ↑n.minFac
state_after: no goals
Theorem: LipschitzWith.of_le_add
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [NNReal.coe_one, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ
f : α → ℝ
h : ∀ (x y : α), f x ≤ f y + dist x y
⊢ ∀ (x y : α), f x ≤ f y + ↑1 * dist x y
state_after: no goals
Theorem: Matrix.diagonal_conjTranspose
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [conjTranspose, diagonal_transpose, diagonal_map (star_zero _)]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
v : n → α
⊢ (diagonal v)ᴴ = diagonal (star v)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
v : n → α
⊢ (diagonal fun m => star (v m)) = diagonal (star v)

tactic: rfl
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
v : n → α
⊢ (diagonal fun m => star (v m)) = diagonal (star v)
state_after: no goals
Theorem: WeierstrassCurve.Affine.map_nonsingular
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp only [Nonsingular, evalEval, W.map_equation hf, map_polynomialX,
  map_polynomialY, map_mapRingHom_evalEval, map_ne_zero_iff f hf]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
hf : Function.Injective ⇑f
x y : R
⊢ (map W f).toAffine.Nonsingular (f x) (f y) ↔ W.Nonsingular x y
state_after: no goals
Theorem: Filter.sup_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g✝ : Filter β
f₁ f₂ : Filter α
g : Filter β
⊢ (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g✝ : Filter β
f₁ f₂ : Filter α
g : Filter β
⊢ (f₁ ⊔ f₂).prod g = f₁.prod g ⊔ f₂.prod g

tactic: rw [Filter.prod, comap_sup, inf_sup_right, ← Filter.prod, ← Filter.prod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g✝ : Filter β
f₁ f₂ : Filter α
g : Filter β
⊢ (f₁ ⊔ f₂).prod g = f₁.prod g ⊔ f₂.prod g
state_after: no goals
Theorem: tendstoUniformly_iff_seq_tendstoUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp_rw [← tendstoUniformlyOn_univ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : l.IsCountablyGenerated
⊢ TendstoUniformly F f l ↔ ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformly (fun n => F (u n)) f atTop
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : l.IsCountablyGenerated
⊢ TendstoUniformlyOn F f l univ ↔ ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop univ

tactic: exact tendstoUniformlyOn_iff_seq_tendstoUniformlyOn
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : l.IsCountablyGenerated
⊢ TendstoUniformlyOn F f l univ ↔ ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop univ
state_after: no goals
Theorem: Finset.antidiagonal.snd_le
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

tactic: rw [le_iff_exists_add]
state_before: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ kl.2 ≤ n
state_after: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.2 + c

tactic: use kl.1
state_before: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.2 + c
state_after: case h
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ n = kl.2 + kl.1

tactic: rwa [mem_antidiagonal, eq_comm, add_comm] at hlk
state_before: case h
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ n = kl.2 + kl.1
state_after: no goals
Theorem: vieta_formula_quadratic
File: Mathlib/Algebra/Ring/Basic.lean

tactic: have : c = x * (b - x) := (eq_neg_of_add_eq_zero_right h).trans (by simp [mul_sub, mul_comm])
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
⊢ ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c
state_after: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c

tactic: refine ⟨b - x, ?_, by simp, by rw [this]⟩
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c
state_after: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ (b - x) * (b - x) - b * (b - x) + c = 0

tactic: rw [this, sub_add, ← sub_mul, sub_self]
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ (b - x) * (b - x) - b * (b - x) + c = 0
state_after: no goals

tactic: simp [mul_sub, mul_comm]
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
⊢ -(x * x - b * x) = x * (b - x)
state_after: no goals

tactic: simp
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ x + (b - x) = b
state_after: no goals

tactic: rw [this]
state_before: R : Type u_1
α : Type u_2
inst✝ : NonUnitalCommRing α
a b✝ c✝ b c x : α
h : x * x - b * x + c = 0
this : c = x * (b - x)
⊢ x * (b - x) = c
state_after: no goals
Theorem: Equiv.Perm.mem_support_cycleOf_iff'
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: rw [mem_support_cycleOf_iff, and_iff_left (mem_support.2 hx)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
hx : f x ≠ x
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ y ∈ (f.cycleOf x).support ↔ f.SameCycle x y
state_after: no goals
Theorem: Finset.card_equiv
File: Mathlib/Data/Finset/Card.lean

tactic: refine card_nbij' e e.symm ?_ ?_ ?_ ?_ <;> simp [hst]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
e : α ≃ β
hst : ∀ (i : α), i ∈ s ↔ e i ∈ t
⊢ s.card = t.card
state_after: no goals
Theorem: Nat.xor_cancel_left
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← Nat.xor_assoc, xor_self, zero_xor]
state_before: n m : ℕ
⊢ n ^^^ (n ^^^ m) = m
state_after: no goals
Theorem: Complex.continuous_normSq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa [← normSq_eq_abs] using continuous_abs.pow 2
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ Continuous ⇑normSq
state_after: no goals