ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: NumberField.mixedEmbedding.disjoint_span_commMap_ker
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
⊢ Disjoint (Submodule.span ℝ (Set.range ⇑(canonicalEmbedding.latticeBasis K))) (LinearMap.ker (commMap K))
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding.latticeBasis K))
h_zero : (commMap K) x = 0
⊢ x = 0
tactic: refine LinearMap.disjoint_ker.mpr (fun x h_mem h_zero => ?_)
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding.latticeBasis K))
h_zero : (commMap K) x = 0
⊢ x = 0
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
⊢ x = 0
tactic: replace h_mem : x ∈ Submodule.span ℝ (Set.range (canonicalEmbedding K)) := by
    refine (Submodule.span_mono ?_) h_mem
    rintro _ ⟨i, rfl⟩
    exact ⟨integralBasis K i, (canonicalEmbedding.latticeBasis_apply K i).symm⟩
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
⊢ x = 0
state_after: case h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
⊢ x φ = 0 φ
tactic: ext1 φ
state_before: case h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
⊢ x φ = 0 φ
state_after: case h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
⊢ x φ = 0
tactic: rw [Pi.zero_apply]
state_before: case h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
⊢ x φ = 0
state_after: case pos
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
hφ : ComplexEmbedding.IsReal φ
⊢ x φ = 0

case neg
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
h_zero : (commMap K) x = 0
h_mem : x ∈ Submodule.span ℝ (Set.range ⇑(canonicalEmbedding K))
φ : K →+* ℂ
hφ : ¬ComplexEmbedding.IsReal φ
⊢ x φ = 0
tactic: by_cases hφ : ComplexEmbedding.IsReal φ
Theorem: Finset.sum_mul_boole
File: Mathlib/Algebra/BigOperators/Ring.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i✝ : ι
a : α
f✝ g : ι → α
inst✝¹ : NonAssocSemiring α
inst✝ : DecidableEq ι
s : Finset ι
f : ι → α
i : ι
⊢ (∑ j ∈ s, f j * if i = j then 1 else 0) = if i ∈ s then f i else 0
state_after: no goals
tactic: simp
Theorem: AlgebraicGeometry.Scheme.Pullback.t_id
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i = 𝟙 (v 𝒰 f g i i)
state_after: case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map i) =
    pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map i)

case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.snd (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map i) =
    pullback.snd (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map i)
tactic: apply pullback.hom_ext <;> rw [Category.id_comp]
Theorem: congr_eqRec
File: .lake/packages/batteries/Batteries/Logic.lean

Proof steps:
state_before: α : Sort u_1
γ : Sort u_2
x x' : α
β : α → Sort u_3
f : (x : α) → β x → γ
h : x = x'
y : β x
⊢ f x' (h ▸ y) = f x y
state_after: case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y
tactic: cases h
state_before: case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y
state_after: no goals
tactic: rfl
Theorem: Set.Icc_eq_singleton_iff
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
⊢ Icc a b = {c} ↔ a = c ∧ b = c
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : Icc a b = {c}
⊢ a = c ∧ b = c

case refine_2
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
⊢ a = c ∧ b = c → Icc a b = {c}
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_intCast
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R
i : ℤ
⊢ WittVector.ghostFun i.castDef = ↑i
state_after: no goals
tactic: cases i <;> simp [*, Int.castDef, ghostFun_natCast, ghostFun_neg, -Pi.natCast_def,
      -Pi.intCast_def]
Theorem: le_div_self_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c d a b : α
⊢ a ≤ a / b ↔ b ≤ 1
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Finset.sum_insert_of_eq_zero_if_not_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
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 α
h : a ∉ s → f a = 1
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x
state_after: case pos
ι : 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 α
h : a ∉ s → f a = 1
hm : a ∈ s
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x

case neg
ι : 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 α
h : a ∉ s → f a = 1
hm : a ∉ s
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x
tactic: by_cases hm : a ∈ s
Theorem: Filter.EventuallyEq.of_indicator
File: Mathlib/Order/Filter/IndicatorFunction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
inst✝ : One β
l : Filter α
f : α → β
hf : ∀ᶠ (x : α) in l, f x ≠ 1
s t : Set α
h : s.mulIndicator f =ᶠ[l] t.mulIndicator f
⊢ s =ᶠ[l] t
state_after: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
inst✝ : One β
l : Filter α
f : α → β
hf : ∀ᶠ (x : α) in l, f x ≠ 1
s t : Set α
h : s.mulIndicator f =ᶠ[l] t.mulIndicator f
this : ∀ {s : Set α}, Function.mulSupport (s.mulIndicator f) =ᶠ[l] s
⊢ s =ᶠ[l] t
tactic: have : ∀ {s : Set α}, Function.mulSupport (s.mulIndicator f) =ᶠ[l] s := fun {s} ↦ by
    rw [mulSupport_mulIndicator]
    exact (hf.mono fun x hx ↦ and_iff_left hx).set_eq
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
inst✝ : One β
l : Filter α
f : α → β
hf : ∀ᶠ (x : α) in l, f x ≠ 1
s t : Set α
h : s.mulIndicator f =ᶠ[l] t.mulIndicator f
this : ∀ {s : Set α}, Function.mulSupport (s.mulIndicator f) =ᶠ[l] s
⊢ s =ᶠ[l] t
state_after: no goals
tactic: exact this.symm.trans <| h.mulSupport.trans this
Theorem: PiNat.cylinder_eq_pi
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
⊢ cylinder x n = (↑(Finset.range n)).pi fun i => {x i}
state_after: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ y ∈ cylinder x n ↔ y ∈ (↑(Finset.range n)).pi fun i => {x i}
tactic: ext y
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ y ∈ cylinder x n ↔ y ∈ (↑(Finset.range n)).pi fun i => {x i}
state_after: no goals
tactic: simp [cylinder]
Theorem: UpperSet.coe_eq_univ
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
⊢ ↑s = univ ↔ s = ⊥
state_after: no goals
tactic: simp [SetLike.ext'_iff]
Theorem: Metric.exists_isOpen_isBounded_image_of_isCompact_of_forall_continuousAt
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : TopologicalSpace β
k : Set β
f : β → α
hk : IsCompact k
hf : ∀ x ∈ k, ContinuousAt f x
⊢ ∃ t, k ⊆ t ∧ IsOpen t ∧ IsBounded (f '' t)
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : TopologicalSpace β
k : Set β
f : β → α
hk : IsCompact k
hf : ∀ x ∈ k, ContinuousWithinAt f univ x
⊢ ∃ t, k ⊆ t ∧ IsOpen t ∧ IsBounded (f '' t)
tactic: simp_rw [← continuousWithinAt_univ] at hf
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : TopologicalSpace β
k : Set β
f : β → α
hk : IsCompact k
hf : ∀ x ∈ k, ContinuousWithinAt f univ x
⊢ ∃ t, k ⊆ t ∧ IsOpen t ∧ IsBounded (f '' t)
state_after: no goals
tactic: simpa only [inter_univ] using
    exists_isOpen_isBounded_image_inter_of_isCompact_of_forall_continuousWithinAt hk hf
Theorem: Set.IsPWO.smul
File: Mathlib/Data/Finset/SMulAntidiagonal.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
⊢ (s • t).IsPWO
state_after: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
⊢ ((fun x => x.1 • x.2) '' s ×ˢ t).IsPWO
tactic: rw [← @image_smul_prod]
state_before: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
⊢ ((fun x => x.1 • x.2) '' s ×ˢ t).IsPWO
state_after: no goals
tactic: exact (hs.prod ht).image_of_monotone (monotone_fst.smul monotone_snd)
Theorem: padicNorm.nonneg
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
q : ℚ
hq : q = 0
⊢ 0 ≤ padicNorm p q
state_after: no goals
tactic: simp [hq, padicNorm]
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ padicNorm p q
state_after: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ if q = 0 then 0 else ↑p ^ (-padicValRat p q)
tactic: unfold padicNorm
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ if q = 0 then 0 else ↑p ^ (-padicValRat p q)
state_after: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p ^ (-padicValRat p q)
tactic: split_ifs
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p ^ (-padicValRat p q)
state_after: case ha
p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p
tactic: apply zpow_nonneg
state_before: case ha
p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p
state_after: no goals
tactic: exact mod_cast Nat.zero_le _
Theorem: HahnSeries.addOppositeEquiv_leadingCoeff
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (AddOpposite.unop (addOppositeEquiv x)).leadingCoeff = AddOpposite.unop x.leadingCoeff
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : AddOpposite.unop (addOppositeEquiv x) = 0 then 0
    else (AddOpposite.unop (addOppositeEquiv x)).coeff (⋯.min ⋯)) =
    AddOpposite.unop (if h : x = 0 then 0 else x.coeff (⋯.min ⋯))
tactic: simp only [leadingCoeff, AddOpposite.unop_op, mk_eq_zero, AddEquivClass.map_eq_zero_iff,
    addOppositeEquiv_support, ne_eq]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : AddOpposite.unop (addOppositeEquiv x) = 0 then 0
    else (AddOpposite.unop (addOppositeEquiv x)).coeff (⋯.min ⋯)) =
    AddOpposite.unop (if h : x = 0 then 0 else x.coeff (⋯.min ⋯))
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : (fun a => AddOpposite.unop (x.coeff a)) = 0 then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : x = 0 then 0 else x.coeff (⋯.min ⋯))
tactic: simp only [addOppositeEquiv_apply, AddOpposite.unop_op, mk_eq_zero, zero_coeff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : (fun a => AddOpposite.unop (x.coeff a)) = 0 then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : x = 0 then 0 else x.coeff (⋯.min ⋯))
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), AddOpposite.unop (x.coeff a) = 0 a then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : ∀ (a : Γ), x.coeff a = coeff 0 a then 0 else x.coeff (⋯.min ⋯))
tactic: simp_rw [HahnSeries.ext_iff x 0, Function.funext_iff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), AddOpposite.unop (x.coeff a) = 0 a then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : ∀ (a : Γ), x.coeff a = coeff 0 a then 0 else x.coeff (⋯.min ⋯))
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), x.coeff a = 0 then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : ∀ (a : Γ), x.coeff a = 0 then 0 else x.coeff (⋯.min ⋯))
tactic: simp only [Pi.zero_apply, AddOpposite.unop_eq_zero_iff, zero_coeff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), x.coeff a = 0 then 0 else AddOpposite.unop (x.coeff (⋯.min ⋯))) =
    AddOpposite.unop (if h : ∀ (a : Γ), x.coeff a = 0 then 0 else x.coeff (⋯.min ⋯))
state_after: no goals
tactic: split <;> rfl
Theorem: EuclideanGeometry.Sphere.secondInter_smul
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
r : ℝ
hr : r ≠ 0
⊢ s.secondInter p (r • v) = s.secondInter p v
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
r : ℝ
hr : r ≠ 0
⊢ (-2 * (r * ⟪v, p -ᵥ s.center⟫_ℝ) / r / r / ⟪v, v⟫_ℝ * r) • v +ᵥ p = (-2 * ⟪v, p -ᵥ s.center⟫_ℝ / ⟪v, v⟫_ℝ) • v +ᵥ p
tactic: simp_rw [Sphere.secondInter, real_inner_smul_left, inner_smul_right, smul_smul,
    div_mul_eq_div_div]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
r : ℝ
hr : r ≠ 0
⊢ (-2 * (r * ⟪v, p -ᵥ s.center⟫_ℝ) / r / r / ⟪v, v⟫_ℝ * r) • v +ᵥ p = (-2 * ⟪v, p -ᵥ s.center⟫_ℝ / ⟪v, v⟫_ℝ) • v +ᵥ p
state_after: no goals
tactic: rw [mul_comm, ← mul_div_assoc, ← mul_div_assoc, mul_div_cancel_left₀ _ hr, mul_comm, mul_assoc,
    mul_div_cancel_left₀ _ hr, mul_comm]
Theorem: Multiset.sum_hom'
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
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✝ : ι → α
inst✝² : CommMonoid β
s : Multiset ι
F : Type u_6
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
g : ι → α
⊢ (map (fun i => f (g i)) s).prod = f (map g s).prod
state_after: case h.e'_2.h.e'_3
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✝ : ι → α
inst✝² : CommMonoid β
s : Multiset ι
F : Type u_6
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
g : ι → α
⊢ map (fun i => f (g i)) s = map (⇑f) (map g s)
tactic: convert (s.map g).prod_hom f
state_before: case h.e'_2.h.e'_3
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✝ : ι → α
inst✝² : CommMonoid β
s : Multiset ι
F : Type u_6
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
g : ι → α
⊢ map (fun i => f (g i)) s = map (⇑f) (map g s)
state_after: no goals
tactic: exact (map_map _ _ _).symm
Theorem: Complex.Gamma_conj
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℂ
⊢ Gamma ((starRingEnd ℂ) s) = (starRingEnd ℂ) (Gamma s)
state_after: s : ℂ
⊢ ∀ (n : ℕ) (s : ℂ), GammaAux n ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux n s)
tactic: suffices ∀ (n : ℕ) (s : ℂ), GammaAux n (conj s) = conj (GammaAux n s) by
    simp [Gamma, this]
state_before: s : ℂ
⊢ ∀ (n : ℕ) (s : ℂ), GammaAux n ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux n s)
state_after: s : ℂ
n : ℕ
⊢ ∀ (s : ℂ), GammaAux n ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux n s)
tactic: intro n
state_before: s : ℂ
n : ℕ
⊢ ∀ (s : ℂ), GammaAux n ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux n s)
state_after: case zero
s : ℂ
⊢ ∀ (s : ℂ), GammaAux 0 ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux 0 s)

case succ
s : ℂ
n : ℕ
IH : ∀ (s : ℂ), GammaAux n ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux n s)
⊢ ∀ (s : ℂ), GammaAux (n + 1) ((starRingEnd ℂ) s) = (starRingEnd ℂ) (GammaAux (n + 1) s)
tactic: induction' n with n IH
Theorem: Nat.Partrec.Code.encode_lt_rfind'
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: cf : Code
⊢ encode cf < encode cf.rfind'
state_after: cf : Code
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
tactic: simp only [encodeCode_eq, encodeCode]
state_before: cf : Code
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
state_after: cf : Code
this : 1 * cf.encodeCode ≤ 2 * 2 * cf.encodeCode
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
tactic: have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2)
state_before: cf : Code
this : 1 * cf.encodeCode ≤ 2 * 2 * cf.encodeCode
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
state_after: cf : Code
this : cf.encodeCode ≤ 2 * (2 * cf.encodeCode)
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
tactic: rw [one_mul, mul_assoc] at this
state_before: cf : Code
this : cf.encodeCode ≤ 2 * (2 * cf.encodeCode)
⊢ cf.encodeCode < 2 * (2 * cf.encodeCode + 1) + 1 + 4
state_after: cf : Code
this : cf.encodeCode ≤ 2 * (2 * cf.encodeCode)
⊢ 2 * (2 * cf.encodeCode) ≤ 2 * (2 * cf.encodeCode + 1) + 1
tactic: refine lt_of_le_of_lt (le_trans this ?_) (lt_add_of_pos_right _ (by decide : 0 < 4))
state_before: cf : Code
this : cf.encodeCode ≤ 2 * (2 * cf.encodeCode)
⊢ 2 * (2 * cf.encodeCode) ≤ 2 * (2 * cf.encodeCode + 1) + 1
state_after: no goals
tactic: exact le_of_lt (Nat.lt_succ_of_le <| Nat.mul_le_mul_left _ <| le_of_lt <|
    Nat.lt_succ_of_le <| Nat.mul_le_mul_left _ <| le_rfl)
Theorem: ContinuousMultilinearMap.norm_ofSubsingleton
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f✝ g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
f : G →L[𝕜] G'
⊢ ‖(ofSubsingleton 𝕜 G G' i) f‖ = ‖f‖
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f✝ g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
f : G →L[𝕜] G'
this : Unique ι := uniqueOfSubsingleton i
⊢ ‖(ofSubsingleton 𝕜 G G' i) f‖ = ‖f‖
tactic: letI : Unique ι := uniqueOfSubsingleton i
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f✝ g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
f : G →L[𝕜] G'
this : Unique ι := uniqueOfSubsingleton i
⊢ ‖(ofSubsingleton 𝕜 G G' i) f‖ = ‖f‖
state_after: no goals
tactic: simp [norm_def, ContinuousLinearMap.norm_def, (Equiv.funUnique _ _).symm.surjective.forall]
Theorem: one_sub_goldConj
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ 1 - φ = ψ
state_after: no goals
tactic: linarith [gold_add_goldConj]
Theorem: Units.mul_right_inj
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c✝ u a : αˣ
b c : α
h : ↑a * b = ↑a * c
⊢ b = c
state_after: no goals
tactic: simpa only [inv_mul_cancel_left] using congr_arg (fun x : α => ↑(a⁻¹ : αˣ) * x) h
Theorem: Bornology.IsVonNBounded.add
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝⁴ : SeminormedRing 𝕜
inst✝³ : AddZeroClass E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : DistribSMul 𝕜 E
s t : Set E
hs : IsVonNBounded 𝕜 s
ht : IsVonNBounded 𝕜 t
U : Set E
hU : U ∈ 𝓝 0
⊢ Absorbs 𝕜 U (s + t)
state_after: case intro.intro.intro
𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝⁴ : SeminormedRing 𝕜
inst✝³ : AddZeroClass E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : DistribSMul 𝕜 E
s t : Set E
hs : IsVonNBounded 𝕜 s
ht : IsVonNBounded 𝕜 t
U : Set E
hU : U ∈ 𝓝 0
V : Set E
hVo : IsOpen V
hV : 0 ∈ V
hVU : V + V ⊆ U
⊢ Absorbs 𝕜 U (s + t)
tactic: rcases exists_open_nhds_zero_add_subset hU with ⟨V, hVo, hV, hVU⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝⁴ : SeminormedRing 𝕜
inst✝³ : AddZeroClass E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : DistribSMul 𝕜 E
s t : Set E
hs : IsVonNBounded 𝕜 s
ht : IsVonNBounded 𝕜 t
U : Set E
hU : U ∈ 𝓝 0
V : Set E
hVo : IsOpen V
hV : 0 ∈ V
hVU : V + V ⊆ U
⊢ Absorbs 𝕜 U (s + t)
state_after: no goals
tactic: exact ((hs <| hVo.mem_nhds hV).add (ht <| hVo.mem_nhds hV)).mono_left hVU