1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.exists_of_eraseP
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [pb]
state_before: α : Type u_1
p : α → Bool
b : α
l : List α
a : α
al : a ∈ b :: l
pa : p a = true
pb : p b = true
⊢ b :: l = [] ++ b :: l ∧ eraseP p (b :: l) = [] ++ l
state_after: no goals

tactic: rw [h₃, cons_append]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ b :: l = b :: l₁ ++ c :: l₂
state_after: no goals

tactic: simp [pb, h₄]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ eraseP p (b :: l) = b :: l₁ ++ l₂
state_after: no goals
Theorem: isSimpleOrder_iff_isSimpleOrder_orderDual
File: Mathlib/Order/Atoms.lean

tactic: constructor <;> intro i <;> haveI := i
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
⊢ IsSimpleOrder α ↔ IsSimpleOrder αᵒᵈ
state_after: case mp
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder α
⊢ IsSimpleOrder αᵒᵈ

case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder αᵒᵈ
⊢ IsSimpleOrder α

tactic: exact
  { exists_pair_ne := @exists_pair_ne α _
    eq_bot_or_eq_top := fun a => Or.symm (eq_bot_or_eq_top (OrderDual.ofDual a) : _ ∨ _) }
state_before: case mp
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder α
⊢ IsSimpleOrder αᵒᵈ
state_after: no goals

tactic: exact
  { exists_pair_ne := @exists_pair_ne αᵒᵈ _
    eq_bot_or_eq_top := fun a => Or.symm (eq_bot_or_eq_top (OrderDual.toDual a)) }
state_before: case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : LE α
inst✝ : BoundedOrder α
i this : IsSimpleOrder αᵒᵈ
⊢ IsSimpleOrder α
state_after: no goals
Theorem: Matrix.self_mul_conjTranspose_mulVec_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: simpa only [conjTranspose_conjTranspose] using conjTranspose_mul_self_mulVec_eq_zero Aᴴ _
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
v : m → R
⊢ (A * Aᴴ) *ᵥ v = 0 ↔ Aᴴ *ᵥ v = 0
state_after: no goals
Theorem: Turing.ToPartrec.Code.pred_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [pred]
state_before: v : List ℕ
⊢ pred.eval v = pure [v.headI.pred]
state_after: v : List ℕ
⊢ Nat.rec (Part.some [0]) (fun y x => Part.some [y]) v.headI = Part.some [v.headI - 1]

tactic: cases v.headI <;> simp
state_before: v : List ℕ
⊢ Nat.rec (Part.some [0]) (fun y x => Part.some [y]) v.headI = Part.some [v.headI - 1]
state_after: no goals
Theorem: IsLocalization.mul_add_inv_left
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [mul_comm, ← one_mul z₁, ← Units.inv_mul (IsUnit.liftRight (g.toMonoidHom.restrict M) h y),
  mul_assoc, ← mul_add, Units.inv_mul_eq_iff_eq_mul, Units.inv_mul_cancel_left,
  IsUnit.coe_liftRight]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
h : ∀ (y : ↥M), IsUnit (g ↑y)
y : ↥M
w z₁ z₂ : P
⊢ w * ↑((IsUnit.liftRight ((↑g).restrict M) h) y)⁻¹ + z₁ = z₂ ↔ w + g ↑y * z₁ = g ↑y * z₂
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
h : ∀ (y : ↥M), IsUnit (g ↑y)
y : ↥M
w z₁ z₂ : P
⊢ w + ((↑g).restrict M) y * z₁ = ((↑g).restrict M) y * z₂ ↔ w + g ↑y * z₁ = g ↑y * z₂

tactic: simp [RingHom.toMonoidHom_eq_coe, MonoidHom.restrict_apply]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
h : ∀ (y : ↥M), IsUnit (g ↑y)
y : ↥M
w z₁ z₂ : P
⊢ w + ((↑g).restrict M) y * z₁ = ((↑g).restrict M) y * z₂ ↔ w + g ↑y * z₁ = g ↑y * z₂
state_after: no goals
Theorem: SeparationQuotient.isClosedMap_mk
File: Mathlib/Topology/Inseparable.lean

tactic: rw [range_mk]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
⊢ IsClosed (Set.range mk)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
⊢ IsClosed univ

tactic: exact isClosed_univ
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
⊢ IsClosed univ
state_after: no goals
Theorem: StructureGroupoid.liftPropOn_univ
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: simp [LiftPropOn, LiftProp, LiftPropAt]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type u_5
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : PartialHomeomorph M H
f f' : PartialHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
⊢ LiftPropOn P g univ ↔ LiftProp P g
state_after: no goals
Theorem: max_div_div_right'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simpa only [div_eq_mul_inv] using max_mul_mul_right a b c⁻¹
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / c) (b / c) = max a b / c
state_after: no goals
Theorem: wbtw_midpoint
File: Mathlib/Analysis/Convex/Between.lean

tactic: convert wbtw_pointReflection R (midpoint R x y) x
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ Wbtw R x (midpoint R x y) y
state_after: case h.e'_10
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ y = (pointReflection R (midpoint R x y)) x

tactic: rw [pointReflection_midpoint_left]
state_before: case h.e'_10
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ y = (pointReflection R (midpoint R x y)) x
state_after: no goals
Theorem: Finset.filter_sups_le
File: Mathlib/Data/Finset/Sups.lean

tactic: simp only [← coe_inj, coe_filter, coe_sups, ← mem_coe, Set.sep_sups_le]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁶ : DecidableEq α
inst✝⁵ : DecidableEq β
inst✝⁴ : SemilatticeSup α
inst✝³ : SemilatticeSup β
inst✝² : FunLike F α β
inst✝¹ : SupHomClass F α β
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b c : α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
⊢ filter (fun x => x ≤ a) (s ⊻ t) = filter (fun x => x ≤ a) s ⊻ filter (fun x => x ≤ a) t
state_after: no goals
Theorem: List.pmap_next_eq_rotate_one
File: Mathlib/Data/List/Cycle.lean

tactic: apply List.ext_nthLe
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ pmap l.next l ⋯ = l.rotate 1
state_after: case hl
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ (pmap l.next l ⋯).length = (l.rotate 1).length

case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ ∀ (n : ℕ) (h₁ : n < (pmap l.next l ⋯).length) (h₂ : n < (l.rotate 1).length),
    (pmap l.next l ⋯).nthLe n h₁ = (l.rotate 1).nthLe n h₂

tactic: simp
state_before: case hl
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ (pmap l.next l ⋯).length = (l.rotate 1).length
state_after: no goals

tactic: intros
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ ∀ (n : ℕ) (h₁ : n < (pmap l.next l ⋯).length) (h₂ : n < (l.rotate 1).length),
    (pmap l.next l ⋯).nthLe n h₁ = (l.rotate 1).nthLe n h₂
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
n✝ : ℕ
h₁✝ : n✝ < (pmap l.next l ⋯).length
h₂✝ : n✝ < (l.rotate 1).length
⊢ (pmap l.next l ⋯).nthLe n✝ h₁✝ = (l.rotate 1).nthLe n✝ h₂✝

tactic: rw [nthLe_pmap, nthLe_rotate, next_nthLe _ h]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
n✝ : ℕ
h₁✝ : n✝ < (pmap l.next l ⋯).length
h₂✝ : n✝ < (l.rotate 1).length
⊢ (pmap l.next l ⋯).nthLe n✝ h₁✝ = (l.rotate 1).nthLe n✝ h₂✝
state_after: no goals
Theorem: SimpleGraph.Subgraph.edgeSet_iInf
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iInf]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
f : ι → G.Subgraph
⊢ (⨅ i, f i).edgeSet = (⋂ i, (f i).edgeSet) ∩ G.edgeSet
state_after: no goals
Theorem: isCompact_univ_pi
File: Mathlib/Topology/Compactness/Compact.lean

tactic: convert isCompact_pi_infinite h
state_before: X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ IsCompact (univ.pi s)
state_after: case h.e'_3
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ univ.pi s = {x | ∀ (i : ι), x i ∈ s i}

tactic: simp only [← mem_univ_pi, setOf_mem_eq]
state_before: case h.e'_3
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ univ.pi s = {x | ∀ (i : ι), x i ∈ s i}
state_after: no goals
Theorem: Nat.totient_prime_pow
File: Mathlib/Data/Nat/Totient.lean

tactic: rcases exists_eq_succ_of_ne_zero (pos_iff_ne_zero.1 hn) with ⟨m, rfl⟩
state_before: p : ℕ
hp : Prime p
n : ℕ
hn : 0 < n
⊢ φ (p ^ n) = p ^ (n - 1) * (p - 1)
state_after: case intro
p : ℕ
hp : Prime p
m : ℕ
hn : 0 < m.succ
⊢ φ (p ^ m.succ) = p ^ (m.succ - 1) * (p - 1)

tactic: exact totient_prime_pow_succ hp _
state_before: case intro
p : ℕ
hp : Prime p
m : ℕ
hn : 0 < m.succ
⊢ φ (p ^ m.succ) = p ^ (m.succ - 1) * (p - 1)
state_after: no goals
Theorem: le_perfectClosure_iff
File: Mathlib/FieldTheory/PurelyInseparable.lean

tactic: refine ⟨fun h ↦ (isPurelyInseparable_iff_pow_mem F (ringExpChar F)).2 fun x ↦ ?_,
  fun _ ↦ le_perfectClosure F E L⟩
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
⊢ L ≤ perfectClosure F E ↔ IsPurelyInseparable F ↥L
state_after: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
h : L ≤ perfectClosure F E
x : ↥L
⊢ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F ↥L).range

tactic: obtain ⟨n, y, hy⟩ := h x.2
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
h : L ≤ perfectClosure F E
x : ↥L
⊢ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F ↥L).range
state_after: case intro.intro
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
h : L ≤ perfectClosure F E
x : ↥L
n : ℕ
y : F
hy : (algebraMap F E) y = ↑x ^ ringExpChar F ^ n
⊢ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F ↥L).range

tactic: exact ⟨n, y, (algebraMap L E).injective hy⟩
state_before: case intro.intro
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
L : IntermediateField F E
h : L ≤ perfectClosure F E
x : ↥L
n : ℕ
y : F
hy : (algebraMap F E) y = ↑x ^ ringExpChar F ^ n
⊢ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F ↥L).range
state_after: no goals
Theorem: Matrix.IsHermitian.spectral_theorem
File: Mathlib/LinearAlgebra/Matrix/Spectrum.lean

tactic: rw [← star_mul_self_mul_eq_diagonal, mul_assoc, mul_assoc,
  (Matrix.mem_unitaryGroup_iff).mp (eigenvectorUnitary hA).2, mul_one,
  ← mul_assoc, (Matrix.mem_unitaryGroup_iff).mp (eigenvectorUnitary hA).2, one_mul]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
n : Type u_2
inst✝¹ : Fintype n
A : Matrix n n 𝕜
inst✝ : DecidableEq n
hA : A.IsHermitian
⊢ A = ↑hA.eigenvectorUnitary * diagonal (RCLike.ofReal ∘ hA.eigenvalues) * star ↑hA.eigenvectorUnitary
state_after: no goals
Theorem: LinearMap.map_comp_lTensor
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: simp only [lTensor, rTensor, ← map_comp, id_comp, comp_id]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g✝ : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f : M →ₗ[R] P
g : N →ₗ[R] Q
g' : S →ₗ[R] N
⊢ map f g ∘ₗ lTensor M g' = map f (g ∘ₗ g')
state_after: no goals
Theorem: List.pmap_eq_map_attach
File: Mathlib/Data/List/Basic.lean

tactic: rw [attach, attachWith, map_pmap]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = map (fun x => f ↑x ⋯) l.attach
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = pmap (fun a h => f ↑⟨a, h⟩ ⋯) l ⋯

tactic: exact pmap_congr l fun _ _ _ _ => rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = pmap (fun a h => f ↑⟨a, h⟩ ⋯) l ⋯
state_after: no goals
Theorem: Filter.tendsto_mul_const_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atTop_of_neg hr
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atBot
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.v_comp_XIsoOfEq_inv
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: rw [hq', hpq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q' = q
⊢ p + n = q'
state_after: no goals

tactic: subst hq'
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q' = q
⊢ γ.v p q hpq ≫ (HomologicalComplex.XIsoOfEq G hq').inv = γ.v p q' ⋯
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q' : ℤ
hpq : p + n = q'
⊢ γ.v p q' hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).inv = γ.v p q' ⋯

tactic: simp only [HomologicalComplex.XIsoOfEq, eqToIso_refl, Iso.refl_inv, comp_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q' : ℤ
hpq : p + n = q'
⊢ γ.v p q' hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).inv = γ.v p q' ⋯
state_after: no goals
Theorem: eq_zero_of_sameRay_self_neg
File: Mathlib/LinearAlgebra/Ray.lean

tactic: nontriviality M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
⊢ x = 0

tactic: haveI : Nontrivial R := Module.nontrivial R M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ x = 0

tactic: refine eq_zero_of_sameRay_neg_smul_right (neg_lt_zero.2 (zero_lt_one' R)) ?_
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ SameRay R x (-1 • x)

tactic: rwa [neg_one_smul]
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ SameRay R x (-1 • x)
state_after: no goals
Theorem: Finsupp.onFinset_prod
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp (config := { contextual := true }) [*]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
s : Finset α
f : α → M
g : α → M → N
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
hg : ∀ (a : α), g a 0 = 1
⊢ ∀ x ∈ s, x ∉ (onFinset s f hf).support → g x ((onFinset s f hf) x) = 1
state_after: no goals
Theorem: Nat.eleven_dvd_of_palindrome
File: Mathlib/Data/Nat/Digits.lean

tactic: let dig := (digits 10 n).map fun n : ℕ => (n : ℤ)
state_before: n : ℕ
p : (digits 10 n).Palindrome
h : Even (digits 10 n).length
⊢ 11 ∣ n
state_after: n : ℕ
p : (digits 10 n).Palindrome
h : Even (digits 10 n).length
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
⊢ 11 ∣ n

tactic: replace h : Even dig.length := by rwa [List.length_map]
state_before: n : ℕ
p : (digits 10 n).Palindrome
h : Even (digits 10 n).length
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
⊢ 11 ∣ n
state_after: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
⊢ 11 ∣ n

tactic: refine eleven_dvd_iff.2 ⟨0, (?_ : dig.alternatingSum = 0)⟩
state_before: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
⊢ 11 ∣ n
state_after: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
⊢ dig.alternatingSum = 0

tactic: have := dig.alternatingSum_reverse
state_before: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
⊢ dig.alternatingSum = 0
state_after: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
this : dig.reverse.alternatingSum = (-1) ^ (dig.length + 1) • dig.alternatingSum
⊢ dig.alternatingSum = 0

tactic: rw [(p.map _).reverse_eq, _root_.pow_succ', h.neg_one_pow, mul_one, neg_one_zsmul] at this
state_before: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
this : dig.reverse.alternatingSum = (-1) ^ (dig.length + 1) • dig.alternatingSum
⊢ dig.alternatingSum = 0
state_after: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
this : (List.map (fun n => ↑n) (digits 10 n)).alternatingSum = -dig.alternatingSum
⊢ dig.alternatingSum = 0

tactic: exact eq_zero_of_neg_eq this.symm
state_before: n : ℕ
p : (digits 10 n).Palindrome
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
h : Even dig.length
this : (List.map (fun n => ↑n) (digits 10 n)).alternatingSum = -dig.alternatingSum
⊢ dig.alternatingSum = 0
state_after: no goals

tactic: rwa [List.length_map]
state_before: n : ℕ
p : (digits 10 n).Palindrome
h : Even (digits 10 n).length
dig : List ℤ := List.map (fun n => ↑n) (digits 10 n)
⊢ Even dig.length
state_after: no goals
Theorem: Real.doublingGamma_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

tactic: simp_rw [doublingGamma, Gamma_one_half_eq, add_halves (1 : ℝ), sub_self, Gamma_one, mul_one,
  rpow_zero, mul_one, div_self (sqrt_ne_zero'.mpr pi_pos)]
state_before: ⊢ doublingGamma 1 = 1
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.restrict_const_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [restrict_lintegral_eq_lintegral_restrict _ hs, const_lintegral_restrict]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ ((const α c).restrict s).lintegral μ = c * μ s
state_after: no goals
Theorem: CategoryTheory.nonempty_hom_of_preconnected_groupoid
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: refine equiv_relation _ ?_ fun {j₁ j₂} => Nonempty.intro
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₂
inst✝² : Category.{u₁, u₂} C
G : Type u_1
inst✝¹ : Groupoid G
inst✝ : IsPreconnected G
⊢ ∀ (x y : G), Nonempty (x ⟶ y)
state_after: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₂
inst✝² : Category.{u₁, u₂} C
G : Type u_1
inst✝¹ : Groupoid G
inst✝ : IsPreconnected G
⊢ _root_.Equivalence fun x y => Nonempty (x ⟶ y)
Theorem: Real.logb_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp_rw [logb, div_eq_zero_iff, log_eq_zero]
state_before: b x y : ℝ
⊢ logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1
state_after: b x y : ℝ
⊢ (x = 0 ∨ x = 1 ∨ x = -1) ∨ b = 0 ∨ b = 1 ∨ b = -1 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1

tactic: tauto
state_before: b x y : ℝ
⊢ (x = 0 ∨ x = 1 ∨ x = -1) ∨ b = 0 ∨ b = 1 ∨ b = -1 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1
state_after: no goals