1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Algebra.leftMulMatrix_complex
File: Mathlib/RingTheory/Complex.lean

tactic: ext i j
state_before: z : ℂ
⊢ (leftMulMatrix basisOneI) z = Matrix.of ![![z.re, -z.im], ![z.im, z.re]]
state_after: case a
z : ℂ
i j : Fin 2
⊢ (leftMulMatrix basisOneI) z i j = Matrix.of ![![z.re, -z.im], ![z.im, z.re]] i j

tactic: rw [Algebra.leftMulMatrix_eq_repr_mul, Complex.coe_basisOneI_repr, Complex.coe_basisOneI, mul_re,
  mul_im, Matrix.of_apply]
state_before: case a
z : ℂ
i j : Fin 2
⊢ (leftMulMatrix basisOneI) z i j = Matrix.of ![![z.re, -z.im], ![z.im, z.re]] i j
state_after: case a
z : ℂ
i j : Fin 2
⊢ ![z.re * (![1, I] j).re - z.im * (![1, I] j).im, z.re * (![1, I] j).im + z.im * (![1, I] j).re] i =
    ![![z.re, -z.im], ![z.im, z.re]] i j

tactic: fin_cases j
state_before: case a
z : ℂ
i j : Fin 2
⊢ ![z.re * (![1, I] j).re - z.im * (![1, I] j).im, z.re * (![1, I] j).im + z.im * (![1, I] j).re] i =
    ![![z.re, -z.im], ![z.im, z.re]] i j
state_after: case a.head
z : ℂ
i : Fin 2
⊢ ![z.re * (![1, I] ⟨0, ⋯⟩).re - z.im * (![1, I] ⟨0, ⋯⟩).im, z.re * (![1, I] ⟨0, ⋯⟩).im + z.im * (![1, I] ⟨0, ⋯⟩).re]
      i =
    ![![z.re, -z.im], ![z.im, z.re]] i ⟨0, ⋯⟩

case a.tail.head
z : ℂ
i : Fin 2
⊢ ![z.re * (![1, I] ⟨1, ⋯⟩).re - z.im * (![1, I] ⟨1, ⋯⟩).im, z.re * (![1, I] ⟨1, ⋯⟩).im + z.im * (![1, I] ⟨1, ⋯⟩).re]
      i =
    ![![z.re, -z.im], ![z.im, z.re]] i ⟨1, ⋯⟩

tactic: simp only [Fin.mk_zero, Matrix.cons_val_zero, one_re, mul_one, one_im, mul_zero, sub_zero,
  zero_add]
state_before: case a.head
z : ℂ
i : Fin 2
⊢ ![z.re * (![1, I] ⟨0, ⋯⟩).re - z.im * (![1, I] ⟨0, ⋯⟩).im, z.re * (![1, I] ⟨0, ⋯⟩).im + z.im * (![1, I] ⟨0, ⋯⟩).re]
      i =
    ![![z.re, -z.im], ![z.im, z.re]] i ⟨0, ⋯⟩
state_after: case a.head
z : ℂ
i : Fin 2
⊢ ![z.re, z.im] i = ![![z.re, -z.im], ![z.im, z.re]] i 0

tactic: fin_cases i <;> rfl
state_before: case a.head
z : ℂ
i : Fin 2
⊢ ![z.re, z.im] i = ![![z.re, -z.im], ![z.im, z.re]] i 0
state_after: no goals

tactic: simp only [Fin.mk_one, Matrix.cons_val_one, Matrix.head_cons, I_re, mul_zero, I_im, mul_one,
  zero_sub, add_zero]
state_before: case a.tail.head
z : ℂ
i : Fin 2
⊢ ![z.re * (![1, I] ⟨1, ⋯⟩).re - z.im * (![1, I] ⟨1, ⋯⟩).im, z.re * (![1, I] ⟨1, ⋯⟩).im + z.im * (![1, I] ⟨1, ⋯⟩).re]
      i =
    ![![z.re, -z.im], ![z.im, z.re]] i ⟨1, ⋯⟩
state_after: case a.tail.head
z : ℂ
i : Fin 2
⊢ ![-z.im, z.re] i = ![![z.re, -z.im], ![z.im, z.re]] i 1

tactic: fin_cases i <;> rfl
state_before: case a.tail.head
z : ℂ
i : Fin 2
⊢ ![-z.im, z.re] i = ![![z.re, -z.im], ![z.im, z.re]] i 1
state_after: no goals
Theorem: CategoryTheory.leftDualIso_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ leftDualIso p p = Iso.refl X
state_after: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (leftDualIso p p).hom = (Iso.refl X).hom

tactic: simp only [leftDualIso, Iso.refl_hom, @leftAdjointMate_id _ _ _ _ ⟨X⟩]
state_before: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (leftDualIso p p).hom = (Iso.refl X).hom
state_after: no goals
Theorem: CstarRing.mul_star_self_ne_zero_iff
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: simp only [Ne, mul_star_self_eq_zero_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x * x⋆ ≠ 0 ↔ x ≠ 0
state_after: no goals
Theorem: Rel.comp_right_id
File: Mathlib/Data/Rel.lean

tactic: unfold comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ r • Eq = r
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ (fun x z => ∃ y, r x y ∧ y = z) = r

tactic: ext y
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ (fun x z => ∃ y, r x y ∧ y = z) = r
state_after: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
y : α
x✝ : β
⊢ (∃ y_1, r y y_1 ∧ y_1 = x✝) ↔ r y x✝

tactic: simp
state_before: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
y : α
x✝ : β
⊢ (∃ y_1, r y y_1 ∧ y_1 = x✝) ↔ r y x✝
state_after: no goals
Theorem: MvQPF.wrepr_wMk
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: rw [wrepr, recF_eq', q.P.wDest'_wMk]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ wrepr ((P F).wMk a f' f) = (P F).wMk' (repr (abs ((TypeVec.id ::: wrepr) <$$> ⟨a, (P F).appendContents f' f⟩)))
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((P F).wMk' ∘ repr) (abs ((TypeVec.id ::: recF ((P F).wMk' ∘ repr)) <$$> ⟨a, splitFun f' f⟩)) =
    (P F).wMk' (repr (abs ((TypeVec.id ::: recF ((P F).wMk' ∘ repr)) <$$> ⟨a, (P F).appendContents f' f⟩)))

tactic: rfl
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((P F).wMk' ∘ repr) (abs ((TypeVec.id ::: recF ((P F).wMk' ∘ repr)) <$$> ⟨a, splitFun f' f⟩)) =
    (P F).wMk' (repr (abs ((TypeVec.id ::: recF ((P F).wMk' ∘ repr)) <$$> ⟨a, (P F).appendContents f' f⟩)))
state_after: no goals
Theorem: lift_nhds_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [nhds_eq_comap_uniformity, comap_lift_eq2 hg]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓝 x).lift g = (𝓤 α).lift fun s => g (ball x s)
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓤 α).lift (g ∘ preimage (Prod.mk x)) = (𝓤 α).lift fun s => g (ball x s)

tactic: simp_rw [ball, Function.comp]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓤 α).lift (g ∘ preimage (Prod.mk x)) = (𝓤 α).lift fun s => g (ball x s)
state_after: no goals
Theorem: Nonneg.toNonneg_lt
File: Mathlib/Algebra/Order/Nonneg/Ring.lean

tactic: cases' a with a ha
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : { x // 0 ≤ x }
b : α
⊢ a < toNonneg b ↔ ↑a < b
state_after: case mk
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
b a : α
ha : 0 ≤ a
⊢ ⟨a, ha⟩ < toNonneg b ↔ ↑⟨a, ha⟩ < b

tactic: simp [toNonneg, ha.not_lt]
state_before: case mk
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
b a : α
ha : 0 ≤ a
⊢ ⟨a, ha⟩ < toNonneg b ↔ ↑⟨a, ha⟩ < b
state_after: no goals
Theorem: Equiv.piCongrLeft_sum_inl
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp_rw [piCongrLeft_apply_eq_cast, sumPiEquivProdPi_symm_apply,
  sum_rec_congr _ _ _ (e.symm_apply_apply (inl i)), cast_cast, cast_eq]
state_before: β : Sort ?u.113034
α : Sort ?u.113039
P : β → Sort w
e✝ : α ≃ β
ι'' : Sort u_2
ι : Type u_3
ι' : Type u_4
π : ι'' → Type u_1
e : ι ⊕ ι' ≃ ι''
f : (i : ι) → π (e (inl i))
g : (i : ι') → π (e (inr i))
i : ι
⊢ (piCongrLeft π e) ((sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (inl i)) = f i
state_after: no goals
Theorem: ContinuousMap.prod_apply
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
ι : Type u_3
s : Finset ι
f : ι → C(α, β)
a : α
⊢ (∏ i ∈ s, f i) a = ∏ i ∈ s, (f i) a
state_after: no goals
Theorem: ENNReal.addLECancellable_iff_ne
File: Mathlib/Data/ENNReal/Operations.lean

tactic: constructor
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ AddLECancellable a ↔ a ≠ ⊤
state_after: case mp
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ AddLECancellable a → a ≠ ⊤

case mpr
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a ≠ ⊤ → AddLECancellable a

tactic: rintro h rfl
state_before: case mp
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ AddLECancellable a → a ≠ ⊤
state_after: case mp
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : AddLECancellable ⊤
⊢ False

tactic: refine zero_lt_one.not_le (h ?_)
state_before: case mp
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : AddLECancellable ⊤
⊢ False
state_after: case mp
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : AddLECancellable ⊤
⊢ ⊤ + 1 ≤ ⊤ + 0

tactic: simp
state_before: case mp
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : AddLECancellable ⊤
⊢ ⊤ + 1 ≤ ⊤ + 0
state_after: no goals

tactic: rintro h b c hbc
state_before: case mpr
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a ≠ ⊤ → AddLECancellable a
state_after: case mpr
a✝ b✝ c✝ d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
h : a ≠ ⊤
b c : ℝ≥0∞
hbc : a + b ≤ a + c
⊢ b ≤ c

tactic: apply ENNReal.le_of_add_le_add_left h hbc
state_before: case mpr
a✝ b✝ c✝ d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
h : a ≠ ⊤
b c : ℝ≥0∞
hbc : a + b ≤ a + c
⊢ b ≤ c
state_after: no goals
Theorem: Finite.card_subtype_le
File: Mathlib/Data/Finite/Card.lean

tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
p : α → Prop
⊢ Nat.card { x // p x } ≤ Nat.card α
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
p : α → Prop
this : Fintype α
⊢ Nat.card { x // p x } ≤ Nat.card α

tactic: simpa only [Nat.card_eq_fintype_card, ge_iff_le] using Fintype.card_subtype_le p
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
p : α → Prop
this : Fintype α
⊢ Nat.card { x // p x } ≤ Nat.card α
state_after: no goals
Theorem: ite_sub_ite
File: Mathlib/Algebra/Ring/Defs.lean

tactic: split
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
⊢ ((if P then a else b) - if P then c else d) = if P then a - c else b - d
state_after: case isTrue
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : P
⊢ a - c = a - c

case isFalse
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : ¬P
⊢ b - d = b - d

tactic: repeat rfl
state_before: case isTrue
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : P
⊢ a - c = a - c

case isFalse
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : ¬P
⊢ b - d = b - d
state_after: no goals

tactic: rfl
state_before: case isFalse
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Sub α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : ¬P
⊢ b - d = b - d
state_after: no goals
Theorem: Finset.card_shatterer_le_sum_vcDim
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

tactic: simp_rw [← card_univ, ← card_powersetCard]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
inst✝ : Fintype α
⊢ 𝒜.shatterer.card ≤ ∑ k ∈ Iic 𝒜.vcDim, (Fintype.card α).choose k
state_after: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
inst✝ : Fintype α
⊢ 𝒜.shatterer.card ≤ ∑ x ∈ Iic 𝒜.vcDim, (powersetCard x univ).card

tactic: refine (card_le_card fun s hs ↦ mem_biUnion.2 ⟨card s, ?_⟩).trans card_biUnion_le
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
inst✝ : Fintype α
⊢ 𝒜.shatterer.card ≤ ∑ x ∈ Iic 𝒜.vcDim, (powersetCard x univ).card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t : Finset α
a : α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ 𝒜.shatterer
⊢ s.card ∈ Iic 𝒜.vcDim ∧ s ∈ powersetCard s.card univ

tactic: exact ⟨mem_Iic.2 (mem_shatterer.1 hs).card_le_vcDim, mem_powersetCard_univ.2 rfl⟩
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t : Finset α
a : α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ 𝒜.shatterer
⊢ s.card ∈ Iic 𝒜.vcDim ∧ s ∈ powersetCard s.card univ
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.Compatibility.equivalence₂CounitIso_eq
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

tactic: ext Y'
state_before: A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_6, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{u_5, u_3} B
inst✝ : Category.{u_8, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
⊢ (equivalence₂ eB hF).counitIso = equivalence₂CounitIso eB hF
state_after: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_6, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{u_5, u_3} B
inst✝ : Category.{u_8, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y' : B
⊢ (equivalence₂ eB hF).counitIso.hom.app Y' = (equivalence₂CounitIso eB hF).hom.app Y'

tactic: dsimp [equivalence₂, Iso.refl]
state_before: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_6, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{u_5, u_3} B
inst✝ : Category.{u_8, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y' : B
⊢ (equivalence₂ eB hF).counitIso.hom.app Y' = (equivalence₂CounitIso eB hF).hom.app Y'
state_after: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_6, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{u_5, u_3} B
inst✝ : Category.{u_8, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y' : B
⊢ eB.inverse.map ((equivalence₁ hF).counitIso.hom.app (eB.functor.obj Y')) ≫ eB.unitIso.inv.app Y' =
    (equivalence₂CounitIso eB hF).hom.app Y'

tactic: simp only [equivalence₁CounitIso_eq, equivalence₂CounitIso_hom_app,
  equivalence₁CounitIso_hom_app, Functor.map_comp, assoc]
state_before: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_6, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{u_5, u_3} B
inst✝ : Category.{u_8, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y' : B
⊢ eB.inverse.map ((equivalence₁ hF).counitIso.hom.app (eB.functor.obj Y')) ≫ eB.unitIso.inv.app Y' =
    (equivalence₂CounitIso eB hF).hom.app Y'
state_after: no goals
Theorem: HomologicalComplex.XIsoOfEq_inv_comp_XIsoOfEq_hom
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [XIsoOfEq]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₁ p₂ p₃ : ι
h₂₁ : p₂ = p₁
h₂₃ : p₂ = p₃
⊢ (K.XIsoOfEq h₂₁).inv ≫ (K.XIsoOfEq h₂₃).hom = (K.XIsoOfEq ⋯).hom
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₁ p₂ p₃ : ι
h₂₁ : p₂ = p₁
h₂₃ : p₂ = p₃
⊢ eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯

tactic: simp only [eqToHom_trans]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₁ p₂ p₃ : ι
h₂₁ : p₂ = p₁
h₂₃ : p₂ = p₃
⊢ eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯
state_after: no goals
Theorem: NNReal.mul_iSup
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [← coe_inj, NNReal.coe_mul, NNReal.coe_iSup, NNReal.coe_iSup]
state_before: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ a * ⨆ i, f i = ⨆ i, a * f i
state_after: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ ↑a * ⨆ i, ↑(f i) = ⨆ i, ↑(a * f i)

tactic: exact Real.mul_iSup_of_nonneg (NNReal.coe_nonneg _) _
state_before: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ ↑a * ⨆ i, ↑(f i) = ⨆ i, ↑(a * f i)
state_after: no goals
Theorem: Finsupp.sigma_sum
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [sum, sigma_support, sum_sigma, split_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝¹ : Zero M
l : (i : ι) × αs i →₀ M
inst✝ : AddCommMonoid N
f : (i : ι) × αs i → M → N
⊢ l.sum f = ∑ i ∈ l.splitSupport, (l.split i).sum fun a b => f ⟨i, a⟩ b
state_after: no goals
Theorem: LieSubmodule.lowerCentralSeries_tensor_eq_baseChange
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
k : ℕ
⊢ lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) k = baseChange A (lowerCentralSeries R L M k)
state_after: case zero
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
⊢ lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) 0 = baseChange A (lowerCentralSeries R L M 0)

case succ
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
k : ℕ
ih : lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) k = baseChange A (lowerCentralSeries R L M k)
⊢ lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) (k + 1) = baseChange A (lowerCentralSeries R L M (k + 1))

tactic: simp only [lowerCentralSeries_succ, ih, ← baseChange_top, lie_baseChange]
state_before: case succ
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
k : ℕ
ih : lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) k = baseChange A (lowerCentralSeries R L M k)
⊢ lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) (k + 1) = baseChange A (lowerCentralSeries R L M (k + 1))
state_after: no goals

tactic: simp
state_before: case zero
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
⊢ lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) 0 = baseChange A (lowerCentralSeries R L M 0)
state_after: no goals
Theorem: PartENat.le_coe_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: show (∃ h : True → x.Dom, _) ↔ ∃ h : x.Dom, x.get h ≤ n
state_before: x : PartENat
n : ℕ
⊢ x ≤ ↑n ↔ ∃ (h : x.Dom), x.get h ≤ n
state_after: x : PartENat
n : ℕ
⊢ (∃ (h : True → x.Dom), ∀ (hy : (↑n).Dom), x.get ⋯ ≤ (↑n).get hy) ↔ ∃ (h : x.Dom), x.get h ≤ n

tactic: simp only [forall_prop_of_true, dom_natCast, get_natCast']
state_before: x : PartENat
n : ℕ
⊢ (∃ (h : True → x.Dom), ∀ (hy : (↑n).Dom), x.get ⋯ ≤ (↑n).get hy) ↔ ∃ (h : x.Dom), x.get h ≤ n
state_after: no goals
Theorem: MeasureTheory.integral_univ
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [Measure.restrict_univ]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
⊢ ∫ (x : X) in univ, f x ∂μ = ∫ (x : X), f x ∂μ
state_after: no goals
Theorem: List.chain_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: cases p with | cons n p => exact ⟨n, p⟩
state_before: α : Type u_1
R : α → α → Prop
a b : α
l : List α
p : Chain R a (b :: l)
⊢ R a b ∧ Chain R b l
state_after: no goals

tactic: exact ⟨n, p⟩
state_before: case cons
α : Type u_1
R : α → α → Prop
a b : α
l : List α
n : R a b
p : Chain R b l
⊢ R a b ∧ Chain R b l
state_after: no goals
Theorem: Real.rpow_sub_one'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_sub' hx h, rpow_one]
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
h : y - 1 ≠ 0
⊢ x ^ (y - 1) = x ^ y / x
state_after: no goals
Theorem: Set.image_update_Ioc
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: rw [← Icc_diff_left, ← Icc_diff_left, image_diff (update_injective _ _), image_singleton,
  image_update_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a b : α i
⊢ update f i '' Ioc a b = Ioc (update f i a) (update f i b)
state_after: no goals
Theorem: Multiset.traverse_map
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine Quotient.inductionOn x ?_
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
⊢ traverse h (map g x) = traverse (h ∘ g) x
state_after: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
⊢ ∀ (a : List α), traverse h (map g ⟦a⟧) = traverse (h ∘ g) ⟦a⟧

tactic: intro
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
⊢ ∀ (a : List α), traverse h (map g ⟦a⟧) = traverse (h ∘ g) ⟦a⟧
state_after: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ traverse h (map g ⟦a✝⟧) = traverse (h ∘ g) ⟦a✝⟧

tactic: simp only [traverse, quot_mk_to_coe, map_coe, lift_coe, Function.comp_apply]
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ traverse h (map g ⟦a✝⟧) = traverse (h ∘ g) ⟦a✝⟧
state_after: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ Coe.coe <$> Traversable.traverse h (List.map g a✝) = Coe.coe <$> Traversable.traverse (h ∘ g) a✝

tactic: rw [← Traversable.traverse_map h g, List.map_eq_map]
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ Coe.coe <$> Traversable.traverse h (List.map g a✝) = Coe.coe <$> Traversable.traverse (h ∘ g) a✝
state_after: no goals
Theorem: List.cons_bagInter_of_pos
File: Mathlib/Data/List/Lattice.lean

tactic: cases l₂
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : a ∈ l₂
⊢ (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)
state_after: case nil
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : a ∈ []
⊢ (a :: l₁).bagInter [] = a :: l₁.bagInter ([].erase a)

case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : a ∈ head✝ :: tail✝
⊢ (a :: l₁).bagInter (head✝ :: tail✝) = a :: l₁.bagInter ((head✝ :: tail✝).erase a)

tactic: exact if_pos h
state_before: case nil
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : a ∈ []
⊢ (a :: l₁).bagInter [] = a :: l₁.bagInter ([].erase a)
state_after: no goals

tactic: simp only [List.bagInter, if_pos (elem_eq_true_of_mem h)]
state_before: case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : a ∈ head✝ :: tail✝
⊢ (a :: l₁).bagInter (head✝ :: tail✝) = a :: l₁.bagInter ((head✝ :: tail✝).erase a)
state_after: no goals