1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.det_updateColumn_smul
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [← det_transpose, ← updateRow_transpose, 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
⊢ (M.updateColumn j (s • u)).det = s * (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 * (Mᵀ.updateRow j u).det = s * (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 * (Mᵀ.updateRow j u).det = s * (M.updateColumn j u).det
state_after: no goals
Theorem: List.dlookup_kinsert
File: Mathlib/Data/List/Sigma.lean

tactic: simp only [kinsert, dlookup_cons_eq]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
⊢ dlookup a (kinsert a b l) = some b
state_after: no goals
Theorem: NormedAddGroupHom.sum_apply
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simp only [coe_sum, Finset.sum_apply]
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₂
ι : Type u_5
s : Finset ι
f : ι → NormedAddGroupHom V₁ V₂
v : V₁
⊢ (∑ i ∈ s, f i) v = ∑ i ∈ s, (f i) v
state_after: no goals
Theorem: CategoryTheory.ShortComplex.Exact.comp_descToInjective
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

tactic: have := hS.mono_fromOpcycles
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.224677, u_2} D
inst✝¹ : Abelian C
S : ShortComplex C
hS : S.Exact
J : C
f : S.X₂ ⟶ J
inst✝ : Injective J
hf : S.f ≫ f = 0
⊢ S.g ≫ hS.descToInjective f hf = f
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.224677, u_2} D
inst✝¹ : Abelian C
S : ShortComplex C
hS : S.Exact
J : C
f : S.X₂ ⟶ J
inst✝ : Injective J
hf : S.f ≫ f = 0
this : Mono S.fromOpcycles
⊢ S.g ≫ hS.descToInjective f hf = f

tactic: dsimp [descToInjective]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.224677, u_2} D
inst✝¹ : Abelian C
S : ShortComplex C
hS : S.Exact
J : C
f : S.X₂ ⟶ J
inst✝ : Injective J
hf : S.f ≫ f = 0
this : Mono S.fromOpcycles
⊢ S.g ≫ hS.descToInjective f hf = f
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.224677, u_2} D
inst✝¹ : Abelian C
S : ShortComplex C
hS : S.Exact
J : C
f : S.X₂ ⟶ J
inst✝ : Injective J
hf : S.f ≫ f = 0
this : Mono S.fromOpcycles
⊢ S.g ≫ Injective.factorThru (S.descOpcycles f hf) S.fromOpcycles = f

tactic: simp only [← p_fromOpcycles, assoc, Injective.comp_factorThru, p_descOpcycles]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.224677, u_2} D
inst✝¹ : Abelian C
S : ShortComplex C
hS : S.Exact
J : C
f : S.X₂ ⟶ J
inst✝ : Injective J
hf : S.f ≫ f = 0
this : Mono S.fromOpcycles
⊢ S.g ≫ Injective.factorThru (S.descOpcycles f hf) S.fromOpcycles = f
state_after: no goals
Theorem: FiniteDimensional.finrank_pos_iff_exists_ne_zero
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: rw [← @rank_pos_iff_exists_ne_zero R M, ← finrank_eq_rank]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ ∃ x, x ≠ 0
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ 0 < ↑(finrank R M)

tactic: norm_cast
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ 0 < ↑(finrank R M)
state_after: no goals
Theorem: Nat.iter_fp_bound
File: Mathlib/Data/Nat/Defs.lean

tactic: intro iter_next
state_before: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
⊢ let iter_next := fun n guess => (guess + n / guess) / 2;
  sqrt.iter n k ≤ iter_next n (sqrt.iter n k)
state_after: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
⊢ sqrt.iter n k ≤ iter_next n (sqrt.iter n k)

tactic: unfold sqrt.iter
state_before: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
⊢ sqrt.iter n k ≤ iter_next n (sqrt.iter n k)
state_after: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
⊢ (let next := (k + n / k) / 2;
    if _h : next < k then sqrt.iter n next else k) ≤
    iter_next n
      (let next := (k + n / k) / 2;
      if _h : next < k then sqrt.iter n next else k)

tactic: if h : (k + n / k) / 2 < k then
  simpa [if_pos h] using iter_fp_bound _ _
else
  simpa [if_neg h] using Nat.le_of_not_lt h
state_before: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
⊢ (let next := (k + n / k) / 2;
    if _h : next < k then sqrt.iter n next else k) ≤
    iter_next n
      (let next := (k + n / k) / 2;
      if _h : next < k then sqrt.iter n next else k)
state_after: no goals

tactic: simpa [if_pos h] using iter_fp_bound _ _
state_before: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
h : (k + n / k) / 2 < k
⊢ (let next := (k + n / k) / 2;
    if _h : next < k then sqrt.iter n next else k) ≤
    iter_next n
      (let next := (k + n / k) / 2;
      if _h : next < k then sqrt.iter n next else k)
state_after: no goals

tactic: simpa [if_neg h] using Nat.le_of_not_lt h
state_before: a b c d m n✝ k✝ : ℕ
p q : ℕ → Prop
n k : ℕ
iter_next : ℕ → ℕ → ℕ := fun n guess => (guess + n / guess) / 2
h : ¬(k + n / k) / 2 < k
⊢ (let next := (k + n / k) / 2;
    if _h : next < k then sqrt.iter n next else k) ≤
    iter_next n
      (let next := (k + n / k) / 2;
      if _h : next < k then sqrt.iter n next else k)
state_after: no goals
Theorem: List.trop_minimum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
l : List R
⊢ trop l.minimum = (map (trop ∘ WithTop.some) l).sum
state_after: case nil
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
⊢ trop [].minimum = (map (trop ∘ WithTop.some) []).sum

case cons
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
hd : R
tl : List R
IH : trop tl.minimum = (map (trop ∘ WithTop.some) tl).sum
⊢ trop (hd :: tl).minimum = (map (trop ∘ WithTop.some) (hd :: tl)).sum

tactic: simp
state_before: case nil
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
⊢ trop [].minimum = (map (trop ∘ WithTop.some) []).sum
state_after: no goals

tactic: simp [List.minimum_cons, ← IH]
state_before: case cons
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
hd : R
tl : List R
IH : trop tl.minimum = (map (trop ∘ WithTop.some) tl).sum
⊢ trop (hd :: tl).minimum = (map (trop ∘ WithTop.some) (hd :: tl)).sum
state_after: no goals
Theorem: Filter.map_comap_of_surjective
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [hf.range_eq, univ_mem]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l✝ f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
hf : Surjective f
l : Filter β
⊢ range f ∈ l
state_after: no goals
Theorem: sup_eq_sdiff_sup_sdiff_sup_inf
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sup_inf_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x \ y ⊔ y \ x ⊔ x ⊓ y = (x \ y ⊔ y \ x ⊔ x) ⊓ (x \ y ⊔ y \ x ⊔ y)
state_after: no goals

tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x \ y ⊔ y \ x ⊔ x) ⊓ (x \ y ⊔ y \ x ⊔ y) = (x \ y ⊔ x ⊔ y \ x) ⊓ (x \ y ⊔ (y \ x ⊔ y))
state_after: no goals

tactic: rw [sup_sdiff_right, sup_sdiff_right]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x \ y ⊔ x ⊔ y \ x) ⊓ (x \ y ⊔ (y \ x ⊔ y)) = (x ⊔ y \ x) ⊓ (x \ y ⊔ y)
state_after: no goals

tactic: rw [sup_sdiff_self_right, sup_sdiff_self_left, inf_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x ⊔ y \ x) ⊓ (x \ y ⊔ y) = x ⊔ y
state_after: no goals
Theorem: jacobiSym.zero_left
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rw [Int.gcd_zero_left, Int.natAbs_ofNat]
state_before: b : ℕ
hb : 1 < b
⊢ Int.gcd 0 ↑b ≠ 1
state_after: b : ℕ
hb : 1 < b
⊢ b ≠ 1

tactic: exact hb.ne'
state_before: b : ℕ
hb : 1 < b
⊢ b ≠ 1
state_after: no goals
Theorem: Polynomial.scaleRoots_ne_zero
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: intro h
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
⊢ p.scaleRoots s ≠ 0
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
⊢ False

tactic: have : p.coeff p.natDegree ≠ 0 := mt leadingCoeff_eq_zero.mp hp
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
⊢ False
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this : p.coeff p.natDegree ≠ 0
⊢ False

tactic: have : (scaleRoots p s).coeff p.natDegree = 0 :=
  congr_fun (congr_arg (coeff : R[X] → ℕ → R) h) p.natDegree
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this : p.coeff p.natDegree ≠ 0
⊢ False
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this✝ : p.coeff p.natDegree ≠ 0
this : (p.scaleRoots s).coeff p.natDegree = 0
⊢ False

tactic: rw [coeff_scaleRoots_natDegree] at this
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this✝ : p.coeff p.natDegree ≠ 0
this : (p.scaleRoots s).coeff p.natDegree = 0
⊢ False
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this✝ : p.coeff p.natDegree ≠ 0
this : p.leadingCoeff = 0
⊢ False

tactic: contradiction
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
hp : p ≠ 0
s : R
h : p.scaleRoots s = 0
this✝ : p.coeff p.natDegree ≠ 0
this : p.leadingCoeff = 0
⊢ False
state_after: no goals
Theorem: Stream'.drop_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ drop [].length ([] ++ₛ s) = s
state_after: no goals

tactic: rw [List.length_cons, drop_succ, cons_append_stream, tail_cons, drop_append_stream l s]
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
s : Stream' α
⊢ drop (a :: l).length (a :: l ++ₛ s) = s
state_after: no goals
Theorem: PowerBasis.quotientEquivQuotientMinpolyMap_symm_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp only [quotientEquivQuotientMinpolyMap, toRingEquiv_eq_coe, symm_trans_apply,
  quotEquivQuotMap_symm_apply_mk, ofRingEquiv_symm_apply, quotientEquiv_symm_mk,
  toRingEquiv_symm, RingEquiv.symm_symm, AdjoinRoot.equiv'_apply, coe_ringEquiv, liftHom_mk,
  symm_toRingEquiv]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
pb : PowerBasis R S
I : Ideal R
g : R[X]
⊢ (pb.quotientEquivQuotientMinpolyMap I).symm
      ((Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
        (Polynomial.map (Ideal.Quotient.mk I) g)) =
    (Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ((aeval pb.gen) g)
state_after: no goals
Theorem: Ordinal.blsub_comp
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o'.blsub g

tactic: apply lt_blsub
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o'.blsub g
state_after: no goals
Theorem: Real.arctan_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: constructor <;> linarith [pi_pos]
state_before: ⊢ π / 4 ∈ Ioo (-(π / 2)) (π / 2)
state_after: no goals
Theorem: coe_div_coe
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝² : SetLike S G
inst✝¹ : DivisionMonoid G
inst✝ : SubgroupClass S G
H : S
⊢ ↑H / ↑H = ↑H
state_after: no goals
Theorem: CoxeterSystem.rightInvSeq_singleton
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: simp [rightInvSeq]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ cs.rightInvSeq [i] = [cs.simple i]
state_after: no goals
Theorem: Finset.Ico_subset_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simpa [← coe_subset] using Set.Ico_subset_Ico ha hb
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Ico a₁ b₁ ⊆ Ico a₂ b₂
state_after: no goals
Theorem: Ordnode.all_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balance']
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P (l.balance' x r) ↔ All P l ∧ P x ∧ All P r
state_after: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P
      (if l.size + r.size ≤ 1 then l.node' x r
      else
        if r.size > delta * l.size then l.rotateL x r
        else if l.size > delta * r.size then l.rotateR x r else l.node' x r) ↔
    All P l ∧ P x ∧ All P r

tactic: split_ifs <;> simp [all_node', all_rotateL, all_rotateR]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P
      (if l.size + r.size ≤ 1 then l.node' x r
      else
        if r.size > delta * l.size then l.rotateL x r
        else if l.size > delta * r.size then l.rotateR x r else l.node' x r) ↔
    All P l ∧ P x ∧ All P r
state_after: no goals
Theorem: SetTheory.PGame.neg_equiv_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
state_before: xl xr : Type u
x y : PGame
⊢ -x ≈ y ↔ x ≈ -y
state_after: no goals
Theorem: EuclideanGeometry.Sphere.oangle_center_eq_two_zsmul_oangle
File: Mathlib/Geometry/Euclidean/Angle/Sphere.lean

tactic: rw [mem_sphere, @dist_eq_norm_vsub V] at hp₁ hp₂ hp₃
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₁ : p₂ ≠ p₁
hp₂p₃ : p₂ ≠ p₃
⊢ ∡ p₁ s.center p₃ = 2 • ∡ p₁ p₂ p₃
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : ‖p₁ -ᵥ s.center‖ = s.radius
hp₂ : ‖p₂ -ᵥ s.center‖ = s.radius
hp₃ : ‖p₃ -ᵥ s.center‖ = s.radius
hp₂p₁ : p₂ ≠ p₁
hp₂p₃ : p₂ ≠ p₃
⊢ ∡ p₁ s.center p₃ = 2 • ∡ p₁ p₂ p₃

tactic: rw [oangle, oangle, o.oangle_eq_two_zsmul_oangle_sub_of_norm_eq_real _ _ hp₂ hp₁ hp₃] <;>
  simp [hp₂p₁, hp₂p₃]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : ‖p₁ -ᵥ s.center‖ = s.radius
hp₂ : ‖p₂ -ᵥ s.center‖ = s.radius
hp₃ : ‖p₃ -ᵥ s.center‖ = s.radius
hp₂p₁ : p₂ ≠ p₁
hp₂p₃ : p₂ ≠ p₃
⊢ ∡ p₁ s.center p₃ = 2 • ∡ p₁ p₂ p₃
state_after: no goals
Theorem: Filter.HasBasis.tendsto_right_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [Tendsto, hlb.ge_iff, mem_map', Filter.Eventually]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hlb : lb.HasBasis pb sb
⊢ Tendsto f la lb ↔ ∀ (i : ι'), pb i → ∀ᶠ (x : α) in la, f x ∈ sb i
state_after: no goals
Theorem: Rep.leftRegularHom_apply
File: Mathlib/RepresentationTheory/Rep.lean

tactic: erw [leftRegularHom_hom, Finsupp.lift_apply, Finsupp.sum_single_index, one_smul,
  A.ρ.map_one, LinearMap.one_apply]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
⊢ (A.leftRegularHom x).hom (Finsupp.single 1 1) = x
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
⊢ 0 • (A.ρ 1) x = 0

tactic: rw [zero_smul]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
⊢ 0 • (A.ρ 1) x = 0
state_after: no goals
Theorem: HomologicalComplex.Hom.next_eq
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.next_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i j : ι
w : c.Rel i j
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f j ≫ (C₂.xNextIso w).inv
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i : ι
w : c.Rel i (c.next i)
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f (c.next i) ≫ (C₂.xNextIso w).inv

tactic: simp only [xNextIso, eqToIso_refl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i : ι
w : c.Rel i (c.next i)
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f (c.next i) ≫ (C₂.xNextIso w).inv
state_after: no goals
Theorem: EuclideanGeometry.Sphere.secondInter_neg
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

tactic: rw [← neg_one_smul ℝ v, s.secondInter_smul p v (by norm_num : (-1 : ℝ) ≠ 0)]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ s.secondInter p (-v) = s.secondInter p v
state_after: no goals

tactic: norm_num
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ -1 ≠ 0
state_after: no goals
Theorem: inv_mem_connectedComponent_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← inv_one]
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 : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1
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 : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1⁻¹

tactic: exact
  Continuous.image_connectedComponent_subset continuous_inv _
    ((Set.mem_image _ _ _).mp ⟨g, hg, rfl⟩)
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 : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1⁻¹
state_after: no goals
Theorem: mfderiv_eq_fderiv
File: Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean

tactic: rw [← mfderivWithin_univ, ← fderivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
⊢ mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') f x = fderiv 𝕜 f x
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
⊢ mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f Set.univ x = fderivWithin 𝕜 f Set.univ x

tactic: exact mfderivWithin_eq_fderivWithin
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
⊢ mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f Set.univ x = fderivWithin 𝕜 f Set.univ x
state_after: no goals
Theorem: MvPolynomial.scalarRTensor_apply_X_tmul_apply
File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

tactic: rw [scalarRTensor_apply_tmul_apply, coeff_X', ite_smul, one_smul, zero_smul]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
σ : Type u_1
inst✝⁴ : DecidableEq σ
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
s : σ
n : N
d : σ →₀ ℕ
⊢ (scalarRTensor (X s ⊗ₜ[R] n)) d = if Finsupp.single s 1 = d then n else 0
state_after: no goals