1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WellFounded.iSup_eq_monotonicSequenceLimit
File: Mathlib/Order/OrderIsoNat.lean

tactic: refine (iSup_le fun m => ?_).antisymm (le_iSup a _)
state_before: α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
⊢ iSup ⇑a = monotonicSequenceLimit a
state_after: α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
⊢ a m ≤ monotonicSequenceLimit a

tactic: rcases le_or_lt m (monotonicSequenceLimitIndex a) with hm | hm
state_before: α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
⊢ a m ≤ monotonicSequenceLimit a
state_after: case inl
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : m ≤ monotonicSequenceLimitIndex a
⊢ a m ≤ monotonicSequenceLimit a

case inr
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
⊢ a m ≤ monotonicSequenceLimit a

tactic: exact a.monotone hm
state_before: case inl
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : m ≤ monotonicSequenceLimitIndex a
⊢ a m ≤ monotonicSequenceLimit a
state_after: no goals

tactic: cases' WellFounded.monotone_chain_condition'.1 h a with n hn
state_before: case inr
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
⊢ a m ≤ monotonicSequenceLimit a
state_after: case inr.intro
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → ¬a n < a m
⊢ a m ≤ monotonicSequenceLimit a

tactic: have : n ∈ {n | ∀ m, n ≤ m → a n = a m} := fun k hk => (a.mono hk).eq_of_not_lt (hn k hk)
state_before: case inr.intro
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → ¬a n < a m
⊢ a m ≤ monotonicSequenceLimit a
state_after: case inr.intro
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → ¬a n < a m
this : n ∈ {n | ∀ (m : ℕ), n ≤ m → a n = a m}
⊢ a m ≤ monotonicSequenceLimit a

tactic: exact (Nat.sInf_mem ⟨n, this⟩ m hm.le).ge
state_before: case inr.intro
α : Type u_1
inst✝ : CompleteLattice α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
m : ℕ
hm : monotonicSequenceLimitIndex a < m
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → ¬a n < a m
this : n ∈ {n | ∀ (m : ℕ), n ≤ m → a n = a m}
⊢ a m ≤ monotonicSequenceLimit a
state_after: no goals
Theorem: Ultrafilter.union_mem_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [← mem_coe, ← le_principal_iff, ← sup_principal, le_sup_iff]
state_before: α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
⊢ s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f
state_after: no goals
Theorem: AddCommGrp.exact_iff
File: Mathlib/Algebra/Category/Grp/Abelian.lean

tactic: rw [Abelian.exact_iff' f g (kernelIsLimit _) (cokernelIsColimit _)]
state_before: X Y Z : AddCommGrp
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ AddMonoidHom.range f = AddMonoidHom.ker g
state_after: X Y Z : AddCommGrp
f : X ⟶ Y
g : Y ⟶ Z
⊢ f ≫ g = 0 ∧ Fork.ι (kernelCone g) ≫ Cofork.π (cokernelCocone f) = 0 ↔ AddMonoidHom.range f = AddMonoidHom.ker g

tactic: exact
  ⟨fun h => ((AddMonoidHom.range_le_ker_iff _ _).mpr h.left).antisymm
      ((QuotientAddGroup.ker_le_range_iff _ _).mpr h.right),
    fun h => ⟨(AddMonoidHom.range_le_ker_iff _ _).mp h.le,
        (QuotientAddGroup.ker_le_range_iff _ _).mp h.symm.le⟩⟩
state_before: X Y Z : AddCommGrp
f : X ⟶ Y
g : Y ⟶ Z
⊢ f ≫ g = 0 ∧ Fork.ι (kernelCone g) ≫ Cofork.π (cokernelCocone f) = 0 ↔ AddMonoidHom.range f = AddMonoidHom.ker g
state_after: no goals
Theorem: qrSign.symm
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rw [neg_one_pow hm hn, neg_one_pow hn hm, mul_comm (m / 2)]
state_before: m n : ℕ
hm : Odd m
hn : Odd n
⊢ qrSign m n = qrSign n m
state_after: no goals
Theorem: Valuation.map_one_sub_of_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [← v.map_one, ← v.map_neg] at h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < 1
⊢ v (1 - x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 - x) = 1

tactic: rw [sub_eq_add_neg 1 x]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 - x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 + -x) = 1

tactic: simpa only [v.map_one, v.map_neg] using v.map_add_eq_of_lt_left h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 + -x) = 1
state_after: no goals
Theorem: Complex.toMatrix_conjAe
File: Mathlib/Data/Complex/Module.lean

tactic: ext i j
state_before: ⊢ (LinearMap.toMatrix basisOneI basisOneI) conjAe.toLinearMap = Matrix.of ![![1, 0], ![0, -1]]
state_after: case a
i j : Fin 2
⊢ (LinearMap.toMatrix basisOneI basisOneI) conjAe.toLinearMap i j = Matrix.of ![![1, 0], ![0, -1]] i j

tactic: fin_cases i <;> fin_cases j <;> simp [LinearMap.toMatrix_apply]
state_before: case a
i j : Fin 2
⊢ (LinearMap.toMatrix basisOneI basisOneI) conjAe.toLinearMap i j = Matrix.of ![![1, 0], ![0, -1]] i j
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.le_boundedBy
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: rw [boundedBy , le_ofFunction, forall_congr']
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), μ s ≤ m s
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ ⨆ (_ : a.Nonempty), m a ↔ μ a ≤ m a

tactic: intro s
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ ⨆ (_ : a.Nonempty), m a ↔ μ a ≤ m a
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ ⨆ (_ : s.Nonempty), m s ↔ μ s ≤ m s

tactic: rcases s.eq_empty_or_nonempty with h | h <;> simp [h, Set.not_nonempty_empty]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ ⨆ (_ : s.Nonempty), m s ↔ μ s ≤ m s
state_after: no goals
Theorem: AddChar.mulShift_mulShift
File: Mathlib/Algebra/Group/AddChar.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s : R
⊢ (ψ.mulShift r).mulShift s = ψ.mulShift (r * s)
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ ((ψ.mulShift r).mulShift s) x✝ = (ψ.mulShift (r * s)) x✝

tactic: simp only [mulShift_apply, mul_assoc]
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ ((ψ.mulShift r).mulShift s) x✝ = (ψ.mulShift (r * s)) x✝
state_after: no goals
Theorem: PartialEquiv.forall_mem_target
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: rw [← image_source_eq_target, forall_mem_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
p : β → Prop
⊢ (∀ y ∈ e.target, p y) ↔ ∀ x ∈ e.source, p (↑e x)
state_after: no goals
Theorem: MeasurableEquiv.withDensity_ofReal_map_symm_apply_eq_integral_abs_det_fderiv_mul
File: Mathlib/MeasureTheory/Function/Jacobian.lean

tactic: rw [MeasurableEquiv.map_symm,
  MeasurableEmbedding.withDensity_ofReal_comap_apply_eq_integral_abs_det_fderiv_mul μ hs
    f.measurableEmbedding hg hg_int hf']
state_before: E : Type u_1
F : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f✝ : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hs : MeasurableSet s
f : E ≃ᵐ E
g : E → ℝ
hg : ∀ᵐ (x : E) ∂μ, x ∈ ⇑f '' s → 0 ≤ g x
hg_int : IntegrableOn g (⇑f '' s) μ
hf' : ∀ x ∈ s, HasFDerivWithinAt (⇑f) (f' x) s x
⊢ (Measure.map (⇑f.symm) (μ.withDensity fun x => ENNReal.ofReal (g x))) s =
    ENNReal.ofReal (∫ (x : E) in s, |(f' x).det| * g (f x) ∂μ)
state_after: no goals
Theorem: ContinuousLinearMap.le_of_opNorm_le_of_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

tactic: gcongr
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ x : E
a b : ℝ
hf : ‖f‖ ≤ a
hx : ‖x‖ ≤ b
⊢ ‖f‖ * ‖x‖ ≤ a * b
state_after: case b0
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ x : E
a b : ℝ
hf : ‖f‖ ≤ a
hx : ‖x‖ ≤ b
⊢ 0 ≤ a

tactic: exact (opNorm_nonneg f).trans hf
state_before: case b0
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ x : E
a b : ℝ
hf : ‖f‖ ≤ a
hx : ‖x‖ ≤ b
⊢ 0 ≤ a
state_after: no goals
Theorem: Set.Icc_diff_pi_univ_Ioc_subset
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: rintro a ⟨⟨hax, haz⟩, hay⟩
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z : (i : ι) → α i
⊢ (Icc x z \ univ.pi fun i => Ioc (y i) (z i)) ⊆ ⋃ i, Icc x (update z i (y i))
state_after: case intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z a : (i : ι) → α i
hay : a ∉ univ.pi fun i => Ioc (y i) (z i)
hax : x ≤ a
haz : a ≤ z
⊢ a ∈ ⋃ i, Icc x (update z i (y i))

tactic: simpa [not_and_or, hax, le_update_iff, haz _] using hay
state_before: case intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z a : (i : ι) → α i
hay : a ∉ univ.pi fun i => Ioc (y i) (z i)
hax : x ≤ a
haz : a ≤ z
⊢ a ∈ ⋃ i, Icc x (update z i (y i))
state_after: no goals
Theorem: Memℓp.sub
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [sub_eq_add_neg]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f g : (i : α) → E i
hf : Memℓp f p
hg : Memℓp g p
⊢ Memℓp (f - g) p
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f g : (i : α) → E i
hf : Memℓp f p
hg : Memℓp g p
⊢ Memℓp (f + -g) p

tactic: exact hf.add hg.neg
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f g : (i : α) → E i
hf : Memℓp f p
hg : Memℓp g p
⊢ Memℓp (f + -g) p
state_after: no goals
Theorem: Nat.not_coprime_of_dvd_of_dvd
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: rw [← co.gcd_eq_one]
state_before: d m n : Nat
dgt1 : 1 < d
Hm : d ∣ m
Hn : d ∣ n
co : m.Coprime n
⊢ d ∣ 1
state_after: d m n : Nat
dgt1 : 1 < d
Hm : d ∣ m
Hn : d ∣ n
co : m.Coprime n
⊢ d ∣ m.gcd n

tactic: exact dvd_gcd Hm Hn
state_before: d m n : Nat
dgt1 : 1 < d
Hm : d ∣ m
Hn : d ∣ n
co : m.Coprime n
⊢ d ∣ m.gcd n
state_after: no goals
Theorem: WithTop.not_top_lt
File: Mathlib/Order/WithBot.lean

tactic: rw [← toDual_lt_toDual_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b : α
a : WithTop α
⊢ ¬⊤ < a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b : α
a : WithTop α
⊢ ¬WithTop.toDual a < WithTop.toDual ⊤

tactic: exact WithBot.not_lt_bot _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b : α
a : WithTop α
⊢ ¬WithTop.toDual a < WithTop.toDual ⊤
state_after: no goals
Theorem: Matrix.trace_col_mul_row
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

tactic: apply Finset.sum_congr rfl
state_before: ι✝ : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
ι : Type u_8
inst✝¹ : Unique ι
inst✝ : NonUnitalNonAssocSemiring R
a b : n → R
⊢ (col ι a * row ι b).trace = a ⬝ᵥ b
state_after: ι✝ : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
ι : Type u_8
inst✝¹ : Unique ι
inst✝ : NonUnitalNonAssocSemiring R
a b : n → R
⊢ ∀ x ∈ Finset.univ, (col ι a * row ι b).diag x = a x * b x

tactic: simp [mul_apply]
state_before: ι✝ : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
ι : Type u_8
inst✝¹ : Unique ι
inst✝ : NonUnitalNonAssocSemiring R
a b : n → R
⊢ ∀ x ∈ Finset.univ, (col ι a * row ι b).diag x = a x * b x
state_after: no goals
Theorem: SimpleGraph.Subgraph.coe_deleteEdges_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext ⟨v, hv⟩ ⟨w, hw⟩
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s✝ s : Set (Sym2 V)
⊢ (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)
state_after: case Adj.h.mk.h.mk.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s✝ s : Set (Sym2 V)
v : V
hv : v ∈ (G'.deleteEdges s).verts
w : V
hw : w ∈ (G'.deleteEdges s).verts
⊢ (G'.deleteEdges s).coe.Adj ⟨v, hv⟩ ⟨w, hw⟩ ↔ (G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)).Adj ⟨v, hv⟩ ⟨w, hw⟩

tactic: simp
state_before: case Adj.h.mk.h.mk.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s✝ s : Set (Sym2 V)
v : V
hv : v ∈ (G'.deleteEdges s).verts
w : V
hw : w ∈ (G'.deleteEdges s).verts
⊢ (G'.deleteEdges s).coe.Adj ⟨v, hv⟩ ⟨w, hw⟩ ↔ (G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)).Adj ⟨v, hv⟩ ⟨w, hw⟩
state_after: no goals
Theorem: CategoryTheory.ConcreteCategory.isIso_iff_bijective
File: Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean

tactic: rw [← CategoryTheory.isIso_iff_bijective]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ Function.Bijective ((forget C).map f)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ IsIso ((forget C).map f)

tactic: exact ⟨fun _ ↦ inferInstance, fun _ ↦ isIso_of_reflects_iso f (forget C)⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ IsIso ((forget C).map f)
state_after: no goals
Theorem: neg_one_pow_mul_eq_zero_iff
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rcases neg_one_pow_eq_or R n with h | h <;> simp [h]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring R
a b : R
n : ℕ
⊢ (-1) ^ n * a = 0 ↔ a = 0
state_after: no goals
Theorem: CategoryTheory.ConcreteCategory.hom_ext
File: Mathlib/CategoryTheory/ConcreteCategory/Basic.lean

tactic: apply (forget C).map_injective
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
⊢ f = g
state_after: case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
⊢ (forget C).map f = (forget C).map g

tactic: dsimp [forget]
state_before: case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
⊢ (forget C).map f = (forget C).map g
state_after: case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
⊢ ConcreteCategory.forget.map f = ConcreteCategory.forget.map g

tactic: funext x
state_before: case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
⊢ ConcreteCategory.forget.map f = ConcreteCategory.forget.map g
state_after: case a.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
x : ConcreteCategory.forget.obj X
⊢ ConcreteCategory.forget.map f x = ConcreteCategory.forget.map g x

tactic: exact w x
state_before: case a.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X Y : C
f g : X ⟶ Y
w : ∀ (x : (forget C).obj X), f x = g x
x : ConcreteCategory.forget.obj X
⊢ ConcreteCategory.forget.map f x = ConcreteCategory.forget.map g x
state_after: no goals
Theorem: Multiset.ext
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe, filter_coe, mem_coe, coe_count, decide_eq_true_eq]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
_l₁ _l₂ : List α
⊢ _l₁ ≈ _l₂ ↔ ∀ (a : α), count a ⟦_l₁⟧ = count a ⟦_l₂⟧
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
_l₁ _l₂ : List α
⊢ _l₁ ≈ _l₂ ↔ ∀ (a : α), List.count a _l₁ = List.count a _l₂

tactic: apply perm_iff_count
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
_l₁ _l₂ : List α
⊢ _l₁ ≈ _l₂ ↔ ∀ (a : α), List.count a _l₁ = List.count a _l₂
state_after: no goals
Theorem: Cardinal.toPartENat_congr
File: Mathlib/SetTheory/Cardinal/PartENat.lean

tactic: rw [← toPartENat_lift, lift_mk_eq.{_, _,v}.mpr ⟨e⟩, toPartENat_lift]
state_before: α : Type u
β : Type v
e : α ≃ β
⊢ toPartENat #α = toPartENat #β
state_after: no goals
Theorem: Matrix.inv_smul
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp [h, smul_smul]
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 α
k : α
inst✝ : Invertible k
h : IsUnit A.det
⊢ ⅟k • A⁻¹ * k • A = 1
state_after: no goals
Theorem: ContinuousLinearEquiv.comp_right_hasFDerivAt_iff'
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp only [← hasFDerivWithinAt_univ, ← iso.comp_right_hasFDerivWithinAt_iff', preimage_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
x : E
f' : E →L[𝕜] G
⊢ HasFDerivAt (f ∘ ⇑iso) f' x ↔ HasFDerivAt f (f'.comp ↑iso.symm) (iso x)
state_after: no goals
Theorem: Multiset.bind_hcongr
File: Mathlib/Data/Multiset/Bind.lean

tactic: subst h
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
β' : Type v
m : Multiset α
f : α → Multiset β
f' : α → Multiset β'
h : β = β'
hf : ∀ a ∈ m, HEq (f a) (f' a)
⊢ HEq (m.bind f) (m.bind f')
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
f f' : α → Multiset β
hf : ∀ a ∈ m, HEq (f a) (f' a)
⊢ HEq (m.bind f) (m.bind f')

tactic: simp only [heq_eq_eq] at hf
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
f f' : α → Multiset β
hf : ∀ a ∈ m, HEq (f a) (f' a)
⊢ HEq (m.bind f) (m.bind f')
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
f f' : α → Multiset β
hf : ∀ a ∈ m, f a = f' a
⊢ HEq (m.bind f) (m.bind f')

tactic: simp [bind_congr hf]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
f f' : α → Multiset β
hf : ∀ a ∈ m, f a = f' a
⊢ HEq (m.bind f) (m.bind f')
state_after: no goals
Theorem: Fin.prod_univ_castSucc
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simpa [mul_comm] using prod_univ_succAbove f (last n)
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
⊢ ∏ i : Fin (n + 1), f i = (∏ i : Fin n, f i.castSucc) * f (last n)
state_after: no goals
Theorem: MonoidWithZeroHom.ext_rat'
File: Mathlib/Data/Rat/Cast/Defs.lean

tactic: rw [← r.num_div_den, div_eq_mul_inv, map_mul, map_mul, h, ← Int.cast_natCast,
  eq_on_inv₀ f g]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
M₀ : Type u_5
inst✝² : MonoidWithZero M₀
inst✝¹ : FunLike F ℚ M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
h : ∀ (m : ℤ), f ↑m = g ↑m
r : ℚ
⊢ f r = g r
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
M₀ : Type u_5
inst✝² : MonoidWithZero M₀
inst✝¹ : FunLike F ℚ M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
h : ∀ (m : ℤ), f ↑m = g ↑m
r : ℚ
⊢ f ↑↑r.den = g ↑↑r.den

tactic: apply h
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
M₀ : Type u_5
inst✝² : MonoidWithZero M₀
inst✝¹ : FunLike F ℚ M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
h : ∀ (m : ℤ), f ↑m = g ↑m
r : ℚ
⊢ f ↑↑r.den = g ↑↑r.den
state_after: no goals
Theorem: CategoryTheory.Iso.map_hom_inv_id_eval
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: rw [← F.map_comp, ← GradedObject.categoryOfGradedObjects_comp, e.hom_inv_id,
  GradedObject.categoryOfGradedObjects_id, Functor.map_id]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{u_6, u_2} D
inst✝ : Category.{?u.8913, u_3} E
X Y : GradedObject J C
e : X ≅ Y
F : C ⥤ D
j : J
⊢ F.map (e.hom j) ≫ F.map (e.inv j) = 𝟙 (F.obj (X j))
state_after: no goals