1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsLUB.mul_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_or_eq_of_le ha with (ha | rfl)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsLUB s b
⊢ IsLUB ((fun b => a * b) '' s) (a * b)
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsLUB s b
ha : 0 < a
⊢ IsLUB ((fun b => a * b) '' s) (a * b)

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun b => 0 * b) '' s) (0 * b)

tactic: exact (OrderIso.mulLeft₀ _ ha).isLUB_image'.2 hs
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsLUB s b
ha : 0 < a
⊢ IsLUB ((fun b => a * b) '' s) (a * b)
state_after: no goals

tactic: simp_rw [zero_mul]
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun b => 0 * b) '' s) (0 * b)
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun a => 0) '' s) 0

tactic: rw [hs.nonempty.image_const]
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun a => 0) '' s) 0
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB {0} 0

tactic: exact isLUB_singleton
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB {0} 0
state_after: no goals
Theorem: NormedAddGroupHom.completion_toCompl
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

tactic: ext x
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
⊢ f.completion.comp toCompl = toCompl.comp f
state_after: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ (f.completion.comp toCompl) x = (toCompl.comp f) x

tactic: simp
state_before: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ (f.completion.comp toCompl) x = (toCompl.comp f) x
state_after: no goals
Theorem: Real.zero_rpow_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: by_cases h : x = 0 <;> simp [h, zero_le_one]
state_before: x✝ y z x : ℝ
⊢ 0 ≤ 0 ^ x
state_after: no goals
Theorem: Submonoid.leftInvEquiv_symm_eq_inv
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: rw [← mul_right_inj (x : M), mul_right_inv, mul_leftInvEquiv_symm]
state_before: M : Type u_1
inst✝ : CommGroup M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ ↑((S.leftInvEquiv hS).symm x) = (↑x)⁻¹
state_after: no goals
Theorem: Polynomial.IsWeaklyEisensteinAt.map
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

tactic: refine (isWeaklyEisensteinAt_iff _ _).2 fun hn => ?_
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ (Polynomial.map φ f).IsWeaklyEisensteinAt (Ideal.map φ 𝓟)
state_after: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ (Polynomial.map φ f).coeff n✝ ∈ Ideal.map φ 𝓟

tactic: rw [coeff_map]
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ (Polynomial.map φ f).coeff n✝ ∈ Ideal.map φ 𝓟
state_after: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ φ (f.coeff n✝) ∈ Ideal.map φ 𝓟

tactic: exact mem_map_of_mem _ (hf.mem (lt_of_lt_of_le hn (natDegree_map_le _ _)))
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ φ (f.coeff n✝) ∈ Ideal.map φ 𝓟
state_after: no goals
Theorem: lift_rank_le_of_injective_injective
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

tactic: simp_rw [Module.rank, lift_iSup (bddAbove_range.{v', v'} _), lift_iSup (bddAbove_range.{v, v} _)]
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : R' → R
j : M →+ M'
hi : ∀ (r : R'), i r = 0 → r = 0
hj : Injective ⇑j
hc : ∀ (r : R') (m : M), j (i r • m) = r • j m
⊢ lift.{v', v} (Module.rank R M) ≤ lift.{v, v'} (Module.rank R' M')
state_after: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : R' → R
j : M →+ M'
hi : ∀ (r : R'), i r = 0 → r = 0
hj : Injective ⇑j
hc : ∀ (r : R') (m : M), j (i r • m) = r • j m
⊢ ⨆ i, lift.{v', v} #↑↑i ≤ ⨆ i, lift.{v, v'} #↑↑i

tactic: exact ciSup_mono' (bddAbove_range.{v', v} _) fun ⟨s, h⟩ ↦ ⟨⟨j '' s,
  (h.map_of_injective_injective i j hi (fun _ _ ↦ hj <| by rwa [j.map_zero]) hc).image⟩,
    lift_mk_le'.mpr ⟨(Equiv.Set.image j s hj).toEmbedding⟩⟩
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : R' → R
j : M →+ M'
hi : ∀ (r : R'), i r = 0 → r = 0
hj : Injective ⇑j
hc : ∀ (r : R') (m : M), j (i r • m) = r • j m
⊢ ⨆ i, lift.{v', v} #↑↑i ≤ ⨆ i, lift.{v, v'} #↑↑i
state_after: no goals

tactic: rwa [j.map_zero]
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : R' → R
j : M →+ M'
hi : ∀ (r : R'), i r = 0 → r = 0
hj : Injective ⇑j
hc : ∀ (r : R') (m : M), j (i r • m) = r • j m
x✝² : { s // LinearIndependent (ι := { x // x ∈ s }) R Subtype.val }
s : Set M
h : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
x✝¹ : M
x✝ : j x✝¹ = 0
⊢ j x✝¹ = j 0
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.add_of_Y_ne
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [add, if_neg <| not_equiv_of_Y_ne hy, addXYZ_of_X_eq hP hQ hPz hQz hx]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 ≠ Q y * P z ^ 3
⊢ W.add P Q = addU P Q • ![1, 1, 0]
state_after: no goals
Theorem: Mathlib.Meta.Positivity.pos_of_isRat
File: Mathlib/Tactic/Positivity/Core.lean

tactic: have pos_invOf_d : (0 < ⅟ (d : A)) := pos_invOf_of_invertible_cast d
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
⊢ 0 < e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
⊢ 0 < e

tactic: have pos_n : (0 < (n : A)) := Int.cast_pos (n := n) |>.2 (of_decide_eq_true h)
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
⊢ 0 < e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
pos_n : 0 < ↑n
⊢ 0 < e

tactic: rw [eq]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
pos_n : 0 < ↑n
⊢ 0 < e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
pos_n : 0 < ↑n
⊢ 0 < ↑n * ⅟↑d

tactic: exact mul_pos pos_n pos_invOf_d
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (0 < n) = true
pos_invOf_d : 0 < ⅟↑d
pos_n : 0 < ↑n
⊢ 0 < ↑n * ⅟↑d
state_after: no goals
Theorem: MeasureTheory.Measure.ae_ae_of_ae_compProd
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

tactic: convert kernel.ae_ae_of_ae_compProd h
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : ↥(kernel α β)
inst✝¹ : SFinite μ
inst✝ : IsSFiniteKernel κ
p : α × β → Prop
h : ∀ᵐ (x : α × β) ∂μ ⊗ₘ κ, p x
⊢ ∀ᵐ (a : α) ∂μ, ∀ᵐ (b : β) ∂κ a, p (a, b)
state_after: no goals
Theorem: Filter.HasBasis.tendsto_left_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [Tendsto, (hla.map f).le_iff, image_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hla : la.HasBasis pa sa
⊢ Tendsto f la lb ↔ ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hla : la.HasBasis pa sa
⊢ (∀ t ∈ lb, ∃ i, pa i ∧ sa i ⊆ f ⁻¹' t) ↔ ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hla : la.HasBasis pa sa
⊢ (∀ t ∈ lb, ∃ i, pa i ∧ sa i ⊆ f ⁻¹' t) ↔ ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t
state_after: no goals
Theorem: Subgroup.isOpen_of_mem_nhds
File: Mathlib/Topology/Algebra/OpenSubgroup.lean

tactic: refine isOpen_iff_mem_nhds.2 fun x hx => ?_
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
⊢ IsOpen ↑H
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
⊢ ↑H ∈ 𝓝 x

tactic: have hg' : g ∈ H := SetLike.mem_coe.1 (mem_of_mem_nhds hg)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
⊢ ↑H ∈ 𝓝 x
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
⊢ ↑H ∈ 𝓝 x

tactic: have : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g) :=
  (continuous_id.mul continuous_const).tendsto' _ _ (mul_inv_cancel_left _ _)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
⊢ ↑H ∈ 𝓝 x
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
this : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g)
⊢ ↑H ∈ 𝓝 x

tactic: simpa only [SetLike.mem_coe, Filter.mem_map',
  H.mul_mem_cancel_right (H.mul_mem (H.inv_mem hx) hg')] using this hg
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
this : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g)
⊢ ↑H ∈ 𝓝 x
state_after: no goals
Theorem: MulAction.smul_bijective_of_is_unit
File: Mathlib/GroupTheory/GroupAction/Pointwise.lean

tactic: lift m to Mˣ using hm
state_before: M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : M
hm : IsUnit m
⊢ Function.Bijective fun a => m • a
state_after: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.Bijective fun a => ↑m • a

tactic: rw [Function.bijective_iff_has_inverse]
state_before: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.Bijective fun a => ↑m • a
state_after: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ ∃ g, (Function.LeftInverse g fun a => ↑m • a) ∧ Function.RightInverse g fun a => ↑m • a

tactic: use fun a ↦ m⁻¹ • a
state_before: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ ∃ g, (Function.LeftInverse g fun a => ↑m • a) ∧ Function.RightInverse g fun a => ↑m • a
state_after: case h
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ (Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a) ∧ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a

tactic: constructor
state_before: case h
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ (Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a) ∧ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a
state_after: case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a

case h.right
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a

tactic: intro x
state_before: case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a
state_after: case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
x : α
⊢ (fun a => m⁻¹ • a) ((fun a => ↑m • a) x) = x

tactic: simp [← Units.smul_def]
state_before: case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
x : α
⊢ (fun a => m⁻¹ • a) ((fun a => ↑m • a) x) = x
state_after: no goals

tactic: intro x
state_before: case h.right
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a
state_after: case h.right
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
x : α
⊢ (fun a => ↑m • a) ((fun a => m⁻¹ • a) x) = x

tactic: simp [← Units.smul_def]
state_before: case h.right
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
x : α
⊢ (fun a => ↑m • a) ((fun a => m⁻¹ • a) x) = x
state_after: no goals
Theorem: edist_ne_top_of_mem_ball
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [edist_comm a x, edist_comm a y]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : EMetricSpace β
a : β
r : ℝ≥0∞
x y : ↑(EMetric.ball a r)
⊢ edist a ↑x + edist a ↑y < r + r
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : EMetricSpace β
a : β
r : ℝ≥0∞
x y : ↑(EMetric.ball a r)
⊢ edist (↑x) a + edist (↑y) a < r + r

tactic: exact add_lt_add x.2 y.2
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : EMetricSpace β
a : β
r : ℝ≥0∞
x y : ↑(EMetric.ball a r)
⊢ edist (↑x) a + edist (↑y) a < r + r
state_after: no goals
Theorem: Rat.add_left_neg
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [add_def, normalize_eq_mkRat, Int.neg_mul, Int.add_comm, ← Int.sub_eq_add_neg]
state_before: q a b c : ℚ
⊢ -a + a = 0
state_after: no goals
Theorem: Matroid.Indep.base_of_forall_insert
File: Mathlib/Data/Matroid/Basic.lean

tactic: refine by_contra fun hnb ↦ ?_
state_before: α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
⊢ M.Base B
state_after: α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
⊢ False

tactic: obtain ⟨B', hB'⟩ := M.exists_base
state_before: α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
⊢ False
state_after: case intro
α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
⊢ False

tactic: obtain ⟨e, he, h⟩ := hB.exists_insert_of_not_base hnb hB'
state_before: case intro
α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
⊢ False
state_after: case intro.intro.intro
α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
e : α
he : e ∈ B' \ B
h : M.Indep (insert e B)
⊢ False

tactic: exact hBmax e ⟨hB'.subset_ground he.1, he.2⟩ h
state_before: case intro.intro.intro
α : Type u_1
M✝ M : Matroid α
B : Set α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
e : α
he : e ∈ B' \ B
h : M.Indep (insert e B)
⊢ False
state_after: no goals
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: apply Quiver.Hom.unop_inj
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst = pushout.inl.op
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ ((pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst).unop = pushout.inl.op.unop

tactic: dsimp
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ ((pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst).unop = pushout.inl.op.unop
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ pullback.fst.unop ≫ (pushoutIsoUnopPullback f g).inv = pushout.inl

tactic: rw [← pushoutIsoUnopPullback_inl_hom, Category.assoc, Iso.hom_inv_id, Category.comp_id]
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ pullback.fst.unop ≫ (pushoutIsoUnopPullback f g).inv = pushout.inl
state_after: no goals
Theorem: PNat.Coprime.gcd_mul_left_cancel
File: Mathlib/Data/PNat/Prime.lean

tactic: intro h
state_before: m n k : ℕ+
⊢ k.Coprime n → (k * m).gcd n = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime n
⊢ (k * m).gcd n = m.gcd n

tactic: apply eq
state_before: m n k : ℕ+
h : k.Coprime n
⊢ (k * m).gcd n = m.gcd n
state_after: case a
m n k : ℕ+
h : k.Coprime n
⊢ ↑((k * m).gcd n) = ↑(m.gcd n)

tactic: simp only [gcd_coe, mul_coe]
state_before: case a
m n k : ℕ+
h : k.Coprime n
⊢ ↑((k * m).gcd n) = ↑(m.gcd n)
state_after: case a
m n k : ℕ+
h : k.Coprime n
⊢ (↑k * ↑m).gcd ↑n = (↑m).gcd ↑n

tactic: apply Nat.Coprime.gcd_mul_left_cancel
state_before: case a
m n k : ℕ+
h : k.Coprime n
⊢ (↑k * ↑m).gcd ↑n = (↑m).gcd ↑n
state_after: case a.H
m n k : ℕ+
h : k.Coprime n
⊢ (↑k).Coprime ↑n

tactic: simpa
state_before: case a.H
m n k : ℕ+
h : k.Coprime n
⊢ (↑k).Coprime ↑n
state_after: no goals
Theorem: InnerProductSpaceable.add_left_aux4'
File: Mathlib/Analysis/InnerProductSpace/OfNorm.lean

tactic: rw [add_left_aux3, add_left_aux4]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
y z : E
⊢ (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2 = ‖y + z‖ * ‖y + z‖ - ‖y - z‖ * ‖y - z‖
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
y z : E
⊢ (2 * (‖y + z‖ * ‖y + z‖ + ‖z‖ * ‖z‖) - ‖y‖ * ‖y‖ - (2 * (‖y - z‖ * ‖y - z‖ + ‖z‖ * ‖z‖) - ‖y‖ * ‖y‖)) / 2 =
    ‖y + z‖ * ‖y + z‖ - ‖y - z‖ * ‖y - z‖

tactic: ring
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
y z : E
⊢ (2 * (‖y + z‖ * ‖y + z‖ + ‖z‖ * ‖z‖) - ‖y‖ * ‖y‖ - (2 * (‖y - z‖ * ‖y - z‖ + ‖z‖ * ‖z‖) - ‖y‖ * ‖y‖)) / 2 =
    ‖y + z‖ * ‖y + z‖ - ‖y - z‖ * ‖y - z‖
state_after: no goals
Theorem: MeasureTheory.FinStronglyMeasurable.mul
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine
  ⟨fun n => hf.approx n * hg.approx n, ?_, fun x =>
    (hf.tendsto_approx x).mul (hg.tendsto_approx x)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ FinStronglyMeasurable (f * g) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ ∀ (n : ℕ), μ (support ↑((fun n => hf.approx n * hg.approx n) n)) < ⊤

tactic: intro n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ ∀ (n : ℕ), μ (support ↑((fun n => hf.approx n * hg.approx n) n)) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑((fun n => hf.approx n * hg.approx n) n)) < ⊤

tactic: exact (measure_mono (support_mul_subset_left _ _)).trans_lt (hf.fin_support_approx n)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑((fun n => hf.approx n * hg.approx n) n)) < ⊤
state_after: no goals
Theorem: Real.cos_sq'
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq_add_cos_sq x, add_sub_cancel_left]
state_before: x y : ℝ
⊢ cos x ^ 2 = 1 - sin x ^ 2
state_after: no goals