1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AbsoluteValue.sub_le
File: Mathlib/Algebra/Order/AbsoluteValue.lean

tactic: simpa [sub_eq_add_neg, add_assoc] using abv.add_le (a - b) (b - c)
state_before: ι : Type u_1
α : Type u_2
R✝ : Type u_3
S✝ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : Ring R
inst✝ : OrderedSemiring S
abv : AbsoluteValue R S
a b c : R
⊢ abv (a - c) ≤ abv (a - b) + abv (b - c)
state_after: no goals
Theorem: CategoryTheory.image_ι_op_comp_imageUnopOp_hom
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: simp only [imageUnopOp, Iso.trans, Iso.symm, Iso.op, cokernelOpOp_inv, cokernelEpiComp_hom,
  cokernelCompIsIso_hom, Abelian.coimageIsoImage'_hom, ← Category.assoc, ← op_comp]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (image.ι g.unop).op ≫ (imageUnopOp g).hom = factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (((((kernel.lift (cokernel.π g.unop) (cokernel.π (cokernel.π g.unop).op).unop ⋯ ≫
                  (Abelian.imageIsoImage g.unop).hom) ≫
                image.ι g.unop).op ≫
            (cokernelIsoOfEq ⋯).hom) ≫
          cokernel.desc ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom ⋯) (cokernel.π (kernel.ι g ≫ eqToHom ⋯)) ⋯) ≫
        cokernel.desc (kernel.ι g ≫ eqToHom ⋯) (inv (eqToHom ⋯) ≫ cokernel.π (kernel.ι g)) ⋯) ≫
      cokernel.desc (kernel.ι g) (factorThruImage g) ⋯ =
    factorThruImage g

tactic: simp only [Category.assoc, Abelian.imageIsoImage_hom_comp_image_ι, kernel.lift_ι,
  Quiver.Hom.op_unop, cokernelIsoOfEq_hom_comp_desc_assoc, cokernel.π_desc_assoc,
  cokernel.π_desc]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (((((kernel.lift (cokernel.π g.unop) (cokernel.π (cokernel.π g.unop).op).unop ⋯ ≫
                  (Abelian.imageIsoImage g.unop).hom) ≫
                image.ι g.unop).op ≫
            (cokernelIsoOfEq ⋯).hom) ≫
          cokernel.desc ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom ⋯) (cokernel.π (kernel.ι g ≫ eqToHom ⋯)) ⋯) ≫
        cokernel.desc (kernel.ι g ≫ eqToHom ⋯) (inv (eqToHom ⋯) ≫ cokernel.π (kernel.ι g)) ⋯) ≫
      cokernel.desc (kernel.ι g) (factorThruImage g) ⋯ =
    factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (eqToHom ⋯) ≫ factorThruImage g = factorThruImage g

tactic: simp only [eqToHom_refl]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (eqToHom ⋯) ≫ factorThruImage g = factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (𝟙 A) ≫ factorThruImage g = factorThruImage g

tactic: erw [IsIso.inv_id, Category.id_comp]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (𝟙 A) ≫ factorThruImage g = factorThruImage g
state_after: no goals
Theorem: Nat.disjoint_divisors_filter_isPrimePow
File: Mathlib/Algebra/IsPrimePow.lean

tactic: simp only [Finset.disjoint_left, Finset.mem_filter, and_imp, Nat.mem_divisors, not_and]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a b : ℕ
hab : a.Coprime b
⊢ Disjoint (Finset.filter IsPrimePow a.divisors) (Finset.filter IsPrimePow b.divisors)
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a b : ℕ
hab : a.Coprime b
⊢ ∀ ⦃a_1 : ℕ⦄, a_1 ∣ a → a ≠ 0 → IsPrimePow a_1 → a_1 ∣ b → b ≠ 0 → ¬IsPrimePow a_1

tactic: rintro n han _ha hn hbn _hb -
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a b : ℕ
hab : a.Coprime b
⊢ ∀ ⦃a_1 : ℕ⦄, a_1 ∣ a → a ≠ 0 → IsPrimePow a_1 → a_1 ∣ b → b ≠ 0 → ¬IsPrimePow a_1
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k a b : ℕ
hab : a.Coprime b
n : ℕ
han : n ∣ a
_ha : a ≠ 0
hn : IsPrimePow n
hbn : n ∣ b
_hb : b ≠ 0
⊢ False

tactic: exact hn.ne_one (Nat.eq_one_of_dvd_coprimes hab han hbn)
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k a b : ℕ
hab : a.Coprime b
n : ℕ
han : n ∣ a
_ha : a ≠ 0
hn : IsPrimePow n
hbn : n ∣ b
_hb : b ≠ 0
⊢ False
state_after: no goals
Theorem: CategoryTheory.ChosenFiniteProducts.associator_inv_fst_snd
File: Mathlib/CategoryTheory/ChosenFiniteProducts.lean

tactic: erw [lift_fst_assoc, lift_snd]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ (α_ X Y Z).inv ≫ fst (X ⊗ Y) Z ≫ snd X Y = snd X (Y ⊗ Z) ≫ fst Y Z
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.snd (product X (product Y Z).cone.pt).cone ≫ Limits.BinaryFan.fst (product Y Z).cone =
    snd X (Y ⊗ Z) ≫ fst Y Z

tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.snd (product X (product Y Z).cone.pt).cone ≫ Limits.BinaryFan.fst (product Y Z).cone =
    snd X (Y ⊗ Z) ≫ fst Y Z
state_after: no goals
Theorem: Finset.prod_update_of_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [update_eq_piecewise, prod_piecewise]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ ∏ x ∈ s, update f i b x = b * ∏ x ∈ s \ {i}, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ (∏ x ∈ s ∩ {i}, b) * ∏ x ∈ s \ {i}, f x = b * ∏ x ∈ s \ {i}, f x

tactic: simp [h]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ (∏ x ∈ s ∩ {i}, b) * ∏ x ∈ s \ {i}, f x = b * ∏ x ∈ s \ {i}, f x
state_after: no goals
Theorem: Polynomial.coe_one
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: have := coe_monomial 0 (1 : R)
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : R[X]
⊢ ↑1 = 1
state_after: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : R[X]
this : ↑((monomial 0) 1) = (PowerSeries.monomial R 0) 1
⊢ ↑1 = 1

tactic: rwa [PowerSeries.monomial_zero_eq_C_apply] at this
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : R[X]
this : ↑((monomial 0) 1) = (PowerSeries.monomial R 0) 1
⊢ ↑1 = 1
state_after: no goals
Theorem: Holor.slice_eq
File: Mathlib/Data/Holor.lean

tactic: rw [← hiis]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
x y : Holor α (d :: ds)
h : x.slice = y.slice
t : HolorIndex (d :: ds)
i : ℕ
is : List ℕ
hiis : ↑t = i :: is
⊢ Forall₂ (fun x x_1 => x < x_1) (i :: is) (d :: ds)
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
x y : Holor α (d :: ds)
h : x.slice = y.slice
t : HolorIndex (d :: ds)
i : ℕ
is : List ℕ
hiis : ↑t = i :: is
⊢ Forall₂ (fun x x_1 => x < x_1) (↑t) (d :: ds)

tactic: exact t.2
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
x y : Holor α (d :: ds)
h : x.slice = y.slice
t : HolorIndex (d :: ds)
i : ℕ
is : List ℕ
hiis : ↑t = i :: is
⊢ Forall₂ (fun x x_1 => x < x_1) (↑t) (d :: ds)
state_after: no goals

tactic: rw [h]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
x y : Holor α (d :: ds)
h : x.slice = y.slice
t : HolorIndex (d :: ds)
i : ℕ
is : List ℕ
hiis : ↑t = i :: is
hiisdds : Forall₂ (fun x x_1 => x < x_1) (i :: is) (d :: ds)
hid : i < d
hisds : Forall₂ (fun x x_1 => x < x_1) is ds
⊢ x.slice i hid ⟨is, hisds⟩ = y.slice i hid ⟨is, hisds⟩
state_after: no goals
Theorem: Finset.insert_idem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_insert, ← or_assoc, or_self_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
x : α
⊢ x ∈ insert a (insert a s) ↔ x ∈ insert a s
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.restrict_ofFunction
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: simp
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (fun t => m (t ∩ s)) ∅ = 0
state_after: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ m ∅ = 0

tactic: simp [m_empty]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ m ∅ = 0
state_after: no goals

tactic: rw [restrict]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (restrict s) (OuterMeasure.ofFunction m m_empty) = OuterMeasure.ofFunction (fun t => m (t ∩ s)) ⋯
state_after: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val ∘ₗ comap Subtype.val) (OuterMeasure.ofFunction m m_empty) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) ⋯

tactic: simp only [inter_comm _ s, LinearMap.comp_apply]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val ∘ₗ comap Subtype.val) (OuterMeasure.ofFunction m m_empty) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) ⋯
state_after: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val) ((comap Subtype.val) (OuterMeasure.ofFunction m m_empty)) =
    OuterMeasure.ofFunction (fun t => m (s ∩ t)) ⋯

tactic: rw [comap_ofFunction _ (Or.inl hm)]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val) ((comap Subtype.val) (OuterMeasure.ofFunction m m_empty)) =
    OuterMeasure.ofFunction (fun t => m (s ∩ t)) ⋯
state_after: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val) (OuterMeasure.ofFunction (fun s_1 => m (Subtype.val '' s_1)) ⋯) =
    OuterMeasure.ofFunction (fun t => m (s ∩ t)) ⋯

tactic: simp only [map_ofFunction Subtype.coe_injective, Subtype.image_preimage_coe]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (map Subtype.val) (OuterMeasure.ofFunction (fun s_1 => m (Subtype.val '' s_1)) ⋯) =
    OuterMeasure.ofFunction (fun t => m (s ∩ t)) ⋯
state_after: no goals
Theorem: Multiset.prod_nsmul
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: rw [zero_nsmul, pow_zero]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ (0 • m).prod = m.prod ^ 0
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod 0 = 1

tactic: rfl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod 0 = 1
state_after: no goals

tactic: rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
n : ℕ
⊢ ((n + 1) • m).prod = m.prod ^ (n + 1)
state_after: no goals
Theorem: CategoryTheory.Adjunction.map_restrictFullyFaithful_counit_app
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

tactic: dsimp [restrictFullyFaithful]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map ((restrictFullyFaithful hiC hiD adj comm1 comm2).counit.app X) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map
      (hiD.preimage
        (comm1.inv.app (R.obj X) ≫
          (adj.homEquiv (iC.obj (R.obj X)) (iD.obj X)).symm
              (𝟙 (iC.obj (R.obj X)) ≫ iC.map (𝟙 (R.obj X)) ≫ comm2.inv.app X) ≫
            𝟙 (iD.obj X))) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map
      (hiD.preimage
        (comm1.inv.app (R.obj X) ≫
          (adj.homEquiv (iC.obj (R.obj X)) (iD.obj X)).symm
              (𝟙 (iC.obj (R.obj X)) ≫ iC.map (𝟙 (R.obj X)) ≫ comm2.inv.app X) ≫
            𝟙 (iD.obj X))) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
state_after: no goals
Theorem: TensorProduct.map_id
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: ext
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
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
⊢ map LinearMap.id LinearMap.id = LinearMap.id
state_after: case H.h.h
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
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map LinearMap.id LinearMap.id)) x✝¹) x✝ = (((mk R M N).compr₂ LinearMap.id) x✝¹) x✝

tactic: simp only [mk_apply, id_coe, compr₂_apply, _root_.id, map_tmul]
state_before: case H.h.h
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
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map LinearMap.id LinearMap.id)) x✝¹) x✝ = (((mk R M N).compr₂ LinearMap.id) x✝¹) x✝
state_after: no goals
Theorem: Int.two_mul_ediv_two_add_one_of_odd
File: Mathlib/Algebra/Ring/Int.lean

tactic: rintro ⟨c, rfl⟩
state_before: m n : ℤ
⊢ Odd n → 2 * (n / 2) + 1 = n
state_after: case intro
m c : ℤ
⊢ 2 * ((2 * c + 1) / 2) + 1 = 2 * c + 1

tactic: rw [mul_comm]
state_before: case intro
m c : ℤ
⊢ 2 * ((2 * c + 1) / 2) + 1 = 2 * c + 1
state_after: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1

tactic: convert Int.ediv_add_emod' (2 * c + 1) 2
state_before: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1
state_after: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2

tactic: simp [Int.add_emod]
state_before: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2
state_after: no goals
Theorem: SeparationQuotient.preimage_image_mk_open
File: Mathlib/Topology/Inseparable.lean

tactic: refine Subset.antisymm ?_ (subset_preimage_image _ _)
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)
hs : IsOpen s
⊢ mk ⁻¹' (mk '' s) = s
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)
hs : IsOpen s
⊢ mk ⁻¹' (mk '' s) ⊆ s

tactic: rintro x ⟨y, hys, hxy⟩
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)
hs : IsOpen s
⊢ mk ⁻¹' (mk '' s) ⊆ s
state_after: case intro.intro
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)
hs : IsOpen s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s

tactic: exact ((mk_eq_mk.1 hxy).mem_open_iff hs).1 hys
state_before: case intro.intro
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)
hs : IsOpen s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s
state_after: no goals
Theorem: HasFDerivAt.finset_prod
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: ext
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
ι : Type u_6
𝔸 : Type u_7
𝔸' : Type u_8
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝔸'
u : Finset ι
f : ι → E → 𝔸
f' : ι → E →L[𝕜] 𝔸
g : ι → E → 𝔸'
g' : ι → E →L[𝕜] 𝔸'
inst✝ : DecidableEq ι
x : E
hg : ∀ i ∈ u, HasFDerivAt (g i) (g' i) x
⊢ (∑ i ∈ u.attach, (∏ j ∈ u.attach.erase i, g (↑j) x) • proj i).comp (ContinuousLinearMap.pi fun i => g' ↑i) =
    ∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i
state_after: case h
𝕜 : 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
ι : Type u_6
𝔸 : Type u_7
𝔸' : Type u_8
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝔸'
u : Finset ι
f : ι → E → 𝔸
f' : ι → E →L[𝕜] 𝔸
g : ι → E → 𝔸'
g' : ι → E →L[𝕜] 𝔸'
inst✝ : DecidableEq ι
x : E
hg : ∀ i ∈ u, HasFDerivAt (g i) (g' i) x
x✝ : E
⊢ ((∑ i ∈ u.attach, (∏ j ∈ u.attach.erase i, g (↑j) x) • proj i).comp (ContinuousLinearMap.pi fun i => g' ↑i)) x✝ =
    (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) x✝
Theorem: List.lookupAll_eq_dlookup
File: Mathlib/Data/List/Sigma.lean

tactic: rw [← head?_lookupAll]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (dlookup a l).toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (lookupAll a l).head?.toList

tactic: have h1 := lookupAll_length_le_one a h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (lookupAll a l).head?.toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
h1 : (lookupAll a l).length ≤ 1
⊢ lookupAll a l = (lookupAll a l).head?.toList

tactic: revert h1
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
h1 : (lookupAll a l).length ≤ 1
⊢ lookupAll a l = (lookupAll a l).head?.toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).length ≤ 1 → lookupAll a l = (lookupAll a l).head?.toList

tactic: rcases lookupAll a l with (_ | ⟨b, _ | ⟨c, l⟩⟩) <;> intro h1 <;> try rfl
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).length ≤ 1 → lookupAll a l = (lookupAll a l).head?.toList
state_after: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : l✝.NodupKeys
b c : β a
l : List (β a)
h1 : (b :: c :: l).length ≤ 1
⊢ b :: c :: l = (b :: c :: l).head?.toList

tactic: exact absurd h1 (by simp)
state_before: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : l✝.NodupKeys
b c : β a
l : List (β a)
h1 : (b :: c :: l).length ≤ 1
⊢ b :: c :: l = (b :: c :: l).head?.toList
state_after: no goals

tactic: rfl
state_before: case cons.nil
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
b : β a
h1 : [b].length ≤ 1
⊢ [b] = [b].head?.toList
state_after: no goals

tactic: simp
state_before: α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : l✝.NodupKeys
b c : β a
l : List (β a)
h1 : (b :: c :: l).length ≤ 1
⊢ ¬(b :: c :: l).length ≤ 1
state_after: no goals