1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.isSeparating_op_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine ⟨fun h𝒢 X Y f g hfg => ?_, fun h𝒢 X Y f g hfg => ?_⟩
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
⊢ IsSeparating 𝒢.op ↔ IsCoseparating 𝒢
state_after: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢.op
X Y : C
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ f = g

case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsCoseparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢.op, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g

tactic: refine Quiver.Hom.op_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.unop_inj ?_)
state_before: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢.op
X Y : C
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ f = g
state_after: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢.op
X Y : C
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
G : Cᵒᵖ
hG : G ∈ 𝒢.op
h : G ⟶ { unop := Y }
⊢ (h ≫ f.op).unop = (h ≫ g.op).unop

tactic: simpa only [unop_comp, Quiver.Hom.unop_op] using hfg _ (Set.mem_op.1 hG) _
state_before: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢.op
X Y : C
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
G : Cᵒᵖ
hG : G ∈ 𝒢.op
h : G ⟶ { unop := Y }
⊢ (h ≫ f.op).unop = (h ≫ g.op).unop
state_after: no goals

tactic: refine Quiver.Hom.unop_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.op_inj ?_)
state_before: case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsCoseparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢.op, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g
state_after: case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsCoseparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢.op, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : C
hG : G ∈ 𝒢
h : X.unop ⟶ G
⊢ (f.unop ≫ h).op = (g.unop ≫ h).op

tactic: simpa only [op_comp, Quiver.Hom.op_unop] using hfg _ (Set.op_mem_op.2 hG) _
state_before: case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set C
h𝒢 : IsCoseparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ G ∈ 𝒢.op, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : C
hG : G ∈ 𝒢
h : X.unop ⟶ G
⊢ (f.unop ≫ h).op = (g.unop ≫ h).op
state_after: no goals
Theorem: PNat.prod_factorMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: dsimp [factorMultiset]
state_before: n : ℕ+
⊢ ↑n.factorMultiset.prod = ↑n
state_after: n : ℕ+
⊢ ↑(PrimeMultiset.ofNatList (↑n).factors ⋯).prod = ↑n

tactic: rw [PrimeMultiset.prod_ofNatList]
state_before: n : ℕ+
⊢ ↑(PrimeMultiset.ofNatList (↑n).factors ⋯).prod = ↑n
state_after: n : ℕ+
⊢ (↑n).factors.prod = ↑n

tactic: exact Nat.prod_factors n.ne_zero
state_before: n : ℕ+
⊢ (↑n).factors.prod = ↑n
state_after: no goals
Theorem: MeasureTheory.withDensityᵥ_zero
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
⊢ μ.withDensityᵥ 0 = 0
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ ↑(μ.withDensityᵥ 0) s = ↑0 s

tactic: erw [withDensityᵥ_apply (integrable_zero α E μ) hs]
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ ↑(μ.withDensityᵥ 0) s = ↑0 s
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ ∫ (x : α) in s, 0 ∂μ = ↑0 s

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ ∫ (x : α) in s, 0 ∂μ = ↑0 s
state_after: no goals
Theorem: isOpenMap_prod_of_discrete_left
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp_rw [isOpenMap_iff_nhds_le, Prod.forall, nhds_prod_eq, nhds_discrete, pure_prod, map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
⊢ IsOpenMap f ↔ ∀ (a : α), IsOpenMap fun x => f (a, x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
⊢ (∀ (a : α) (b : β), 𝓝 (f (a, b)) ≤ map (f ∘ Prod.mk a) (𝓝 b)) ↔
    ∀ (a : α) (x : β), 𝓝 (f (a, x)) ≤ map (fun x => f (a, x)) (𝓝 x)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
⊢ (∀ (a : α) (b : β), 𝓝 (f (a, b)) ≤ map (f ∘ Prod.mk a) (𝓝 b)) ↔
    ∀ (a : α) (x : β), 𝓝 (f (a, x)) ≤ map (fun x => f (a, x)) (𝓝 x)
state_after: no goals
Theorem: Finset.union_inter_cancel_right
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_inj, coe_inter, coe_union, Set.union_inter_cancel_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ (s ∪ t) ∩ t = t
state_after: no goals
Theorem: SeminormedAddCommGroup.lipschitzWith_sub
File: Mathlib/Topology/Bornology/BoundedOperation.lean

tactic: convert LipschitzWith.prod_fst.sub LipschitzWith.prod_snd
state_before: R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ LipschitzWith 2 fun p => p.1 - p.2
state_after: case h.e'_5
R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ 2 = 1 + 1

tactic: norm_num
state_before: case h.e'_5
R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ 2 = 1 + 1
state_after: no goals
Theorem: PartialHomeomorph.isBigO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def]
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ f =O[𝓝 b] g ↔ (f ∘ ↑e) =O[𝓝 (↑e.symm b)] (g ∘ ↑e)
state_after: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ (∃ c, IsBigOWith c (𝓝 b) f g) ↔ ∃ c, IsBigOWith c (𝓝 (↑e.symm b)) (f ∘ ↑e) (g ∘ ↑e)

tactic: exact exists_congr fun C => e.isBigOWith_congr hb
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ (∃ c, IsBigOWith c (𝓝 b) f g) ↔ ∃ c, IsBigOWith c (𝓝 (↑e.symm b)) (f ∘ ↑e) (g ∘ ↑e)
state_after: no goals
Theorem: Set.preimage_sub_const_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Ioc b c = Ioc (b + a) (c + a)
state_after: no goals
Theorem: sub_mem_pNilradical_iff_pow_expChar_pow_eq
File: Mathlib/FieldTheory/IsPerfectClosure.lean

tactic: simp_rw [mem_pNilradical, sub_pow_expChar_pow, sub_eq_zero]
state_before: R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : ExpChar R p
x y : R
⊢ x - y ∈ pNilradical R p ↔ ∃ n, x ^ p ^ n = y ^ p ^ n
state_after: no goals
Theorem: Nat.psub_eq_none
File: Mathlib/Data/Nat/PSub.lean

tactic: cases s : psub m n <;> simp [eq_comm]
state_before: m n : ℕ
⊢ m.psub n = none ↔ m < n
state_after: case none
m n : ℕ
s : m.psub n = none
⊢ m < n

case some
m n val✝ : ℕ
s : m.psub n = some val✝
⊢ n ≤ m

tactic: refine lt_of_not_ge fun h => ?_
state_before: case none
m n : ℕ
s : m.psub n = none
⊢ m < n
state_after: case none
m n : ℕ
s : m.psub n = none
h : m ≥ n
⊢ False

tactic: cases' le.dest h with k e
state_before: case none
m n : ℕ
s : m.psub n = none
h : m ≥ n
⊢ False
state_after: case none.intro
m n : ℕ
s : m.psub n = none
h : m ≥ n
k : ℕ
e : n + k = m
⊢ False

tactic: injection s.symm.trans (psub_eq_some.2 <| (add_comm _ _).trans e)
state_before: case none.intro
m n : ℕ
s : m.psub n = none
h : m ≥ n
k : ℕ
e : n + k = m
⊢ False
state_after: no goals

tactic: rw [← psub_eq_some.1 s]
state_before: case some
m n val✝ : ℕ
s : m.psub n = some val✝
⊢ n ≤ m
state_after: case some
m n val✝ : ℕ
s : m.psub n = some val✝
⊢ n ≤ val✝ + n

tactic: apply Nat.le_add_left
state_before: case some
m n val✝ : ℕ
s : m.psub n = some val✝
⊢ n ≤ val✝ + n
state_after: no goals
Theorem: NNReal.nndist_zero_eq_val'
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: rw [nndist_comm]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
z : ℝ≥0
⊢ nndist z 0 = z
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
z : ℝ≥0
⊢ nndist 0 z = z

tactic: exact NNReal.nndist_zero_eq_val z
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
z : ℝ≥0
⊢ nndist 0 z = z
state_after: no goals
Theorem: Real.rpow_of_add_eq
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← h, rpow_add' hx]
state_before: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ x ^ w = x ^ y * x ^ z
state_after: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0

tactic: rwa [h]
state_before: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0
state_after: no goals
Theorem: CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp [← h, he]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ e ≫ g = 0
state_after: no goals

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ kernel.lift f e he ≫ (kernelIsoOfEq h).hom = kernel.lift g e ⋯
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasKernel f
e : Z ⟶ X
he : e ≫ f = 0
inst✝ : HasKernel f
⊢ kernel.lift f e he ≫ (kernelIsoOfEq ⋯).hom = kernel.lift f e ⋯

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasKernel f
e : Z ⟶ X
he : e ≫ f = 0
inst✝ : HasKernel f
⊢ kernel.lift f e he ≫ (kernelIsoOfEq ⋯).hom = kernel.lift f e ⋯
state_after: no goals
Theorem: dist_triangle_left
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [dist_comm z]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist z x + dist z y
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist x z + dist z y

tactic: apply dist_triangle
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist x z + dist z y
state_after: no goals
Theorem: ConvexBody.hausdorffEdist_coe
File: Mathlib/Analysis/Convex/Body.lean

tactic: rw [edist_dist]
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L = edist K L
state_after: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L = ENNReal.ofReal (dist K L)

tactic: exact (ENNReal.ofReal_toReal hausdorffEdist_ne_top).symm
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L = ENNReal.ofReal (dist K L)
state_after: no goals
Theorem: QuaternionAlgebra.star_eq_self
File: Mathlib/Algebra/Quaternion.lean

tactic: simp [QuaternionAlgebra.ext_iff, neg_eq_iff_add_eq_zero, add_self_eq_zero]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝² : CommRing R
c₁✝ c₂✝ r x y z : R
a✝ b c : ℍ[R,c₁✝,c₂✝]
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
c₁ c₂ : R
a : ℍ[R,c₁,c₂]
⊢ star a = a ↔ a = ↑a.re
state_after: no goals
Theorem: InnerProductGeometry.angle_sub_le_pi_div_two_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
⊢ angle x (x - y) ≤ π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ angle x (x - y) ≤ π / 2

tactic: rw [sub_eq_add_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ angle x (x - y) ≤ π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ angle x (x + -y) ≤ π / 2

tactic: exact angle_add_le_pi_div_two_of_inner_eq_zero h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ angle x (x + -y) ≤ π / 2
state_after: no goals
Theorem: MvPolynomial.rTensor_apply_X_tmul
File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

tactic: rw [rTensor_apply_tmul_apply, coeff_X', ite_tmul]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
σ : Type u_1
inst✝⁴ : DecidableEq σ
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
s : σ
n : N
d : σ →₀ ℕ
⊢ (rTensor (X s ⊗ₜ[R] n)) d = if Finsupp.single s 1 = d then 1 ⊗ₜ[R] n else 0
state_after: no goals
Theorem: AlgebraicGeometry.Spec.map_inv
File: Mathlib/AlgebraicGeometry/Scheme.lean

tactic: show Scheme.Spec.map (inv f).op = inv (Scheme.Spec.map f.op)
state_before: R S : CommRingCat
f : R ⟶ S
inst✝ : IsIso f
⊢ map (inv f) = inv (map f)
state_after: R S : CommRingCat
f : R ⟶ S
inst✝ : IsIso f
⊢ Scheme.Spec.map (inv f).op = inv (Scheme.Spec.map f.op)

tactic: rw [op_inv, ← Scheme.Spec.map_inv]
state_before: R S : CommRingCat
f : R ⟶ S
inst✝ : IsIso f
⊢ Scheme.Spec.map (inv f).op = inv (Scheme.Spec.map f.op)
state_after: no goals
Theorem: toIocDiv_sub'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocDiv_sub_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp (a - p) b = toIocDiv hp a b + 1
state_after: no goals
Theorem: Polynomial.coeff_smul
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
n : ℕ
⊢ (r • p).coeff n = r • p.coeff n
state_after: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (r • { toFinsupp := toFinsupp✝ }).coeff n = r • { toFinsupp := toFinsupp✝ }.coeff n

tactic: simp_rw [← ofFinsupp_smul, coeff]
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (r • { toFinsupp := toFinsupp✝ }).coeff n = r • { toFinsupp := toFinsupp✝ }.coeff n
state_after: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (r • toFinsupp✝) n = r • toFinsupp✝ n

tactic: exact Finsupp.smul_apply _ _ _
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (r • toFinsupp✝) n = r • toFinsupp✝ n
state_after: no goals
Theorem: CategoryTheory.Limits.Cocone.ofCofork_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: aesop
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
F : WalkingParallelPair ⥤ C
t : Cofork (F.map left) (F.map right)
j : WalkingParallelPair
⊢ F.obj j = (parallelPair (F.map left) (F.map right)).obj j
state_after: no goals
Theorem: Complex.abs_mul_cos_add_sin_mul_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← exp_mul_I, abs_mul_exp_arg_mul_I]
state_before: a x✝ z x : ℂ
⊢ ↑(abs x) * (cos ↑x.arg + sin ↑x.arg * I) = x
state_after: no goals
Theorem: Equiv.swapCore_comm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: unfold swapCore
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ swapCore a b r = swapCore b a r
state_after: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ (if r = a then b else if r = b then a else r) = if r = b then a else if r = a then b else r

tactic: split_ifs with h₁ h₂ h₃ <;> try simp
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ (if r = a then b else if r = b then a else r) = if r = b then a else if r = a then b else r
state_after: case pos
α : Sort u_1
inst✝ : DecidableEq α
r a b : α
h₁ : r = a
h₂ : r = b
⊢ b = a

tactic: simp
state_before: case neg
α : Sort u_1
inst✝ : DecidableEq α
r a b : α
h₁ : ¬r = a
h₃ : ¬r = b
⊢ r = r
state_after: no goals

tactic: cases h₁
state_before: case pos
α : Sort u_1
inst✝ : DecidableEq α
r a b : α
h₁ : r = a
h₂ : r = b
⊢ b = a
state_after: case pos.refl
α : Sort u_1
inst✝ : DecidableEq α
r b : α
h₂ : r = b
⊢ b = r

tactic: cases h₂
state_before: case pos.refl
α : Sort u_1
inst✝ : DecidableEq α
r b : α
h₂ : r = b
⊢ b = r
state_after: case pos.refl.refl
α : Sort u_1
inst✝ : DecidableEq α
r : α
⊢ r = r

tactic: rfl
state_before: case pos.refl.refl
α : Sort u_1
inst✝ : DecidableEq α
r : α
⊢ r = r
state_after: no goals
Theorem: MeasureTheory.norm_setToFun_le'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [setToFun_eq hT hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖setToFun μ T hT f‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖(L1.setToL1 hT) (Integrable.toL1 f hf)‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖

tactic: exact L1.norm_setToL1_le_mul_norm' hT _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖(L1.setToL1 hT) (Integrable.toL1 f hf)‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
state_after: no goals
Theorem: hasProd_pi_single
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

tactic: convert hasProd_ite_eq b a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ HasProd (Pi.mulSingle b a) a
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
x✝ : β
⊢ Pi.mulSingle b a x✝ = if x✝ = b then a else 1

tactic: simp [Pi.mulSingle_apply]
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
x✝ : β
⊢ Pi.mulSingle b a x✝ = if x✝ = b then a else 1
state_after: no goals
Theorem: List.erase_append_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [erase_eq_eraseP, erase_eq_eraseP, eraseP_append_right]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
h : ¬a ∈ l₁
⊢ (l₁ ++ l₂).erase a = l₁ ++ l₂.erase a
state_after: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
h : ¬a ∈ l₁
⊢ ∀ (b : α), b ∈ l₁ → ¬(a == b) = true

tactic: intros b h' h''
state_before: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
h : ¬a ∈ l₁
⊢ ∀ (b : α), b ∈ l₁ → ¬(a == b) = true
state_after: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
h : ¬a ∈ l₁
b : α
h' : b ∈ l₁
h'' : (a == b) = true
⊢ False

tactic: rw [eq_of_beq h''] at h
state_before: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
h : ¬a ∈ l₁
b : α
h' : b ∈ l₁
h'' : (a == b) = true
⊢ False
state_after: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
b : α
h : ¬b ∈ l₁
h' : b ∈ l₁
h'' : (a == b) = true
⊢ False

tactic: exact h h'
state_before: case a
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₁ l₂ : List α
b : α
h : ¬b ∈ l₁
h' : b ∈ l₁
h'' : (a == b) = true
⊢ False
state_after: no goals
Theorem: CategoryTheory.Equivalence.changeFunctor_trans
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
G G' : C ⥤ D
iso₁ : e.functor ≅ G
iso₂ : G ≅ G'
⊢ (e.changeFunctor iso₁).changeFunctor iso₂ = e.changeFunctor (iso₁ ≪≫ iso₂)
state_after: no goals
Theorem: MeasureTheory.measure_biUnion_eq_iSup
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: haveI := ht.toEncodable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
this : Encodable ↑t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)

tactic: rw [biUnion_eq_iUnion, measure_iUnion_eq_iSup hd.directed_val, ← iSup_subtype'']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
this : Encodable ↑t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)
state_after: no goals