ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Fin.pred_castSucc_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin (n + 1)
ha : a.castSucc ≠ 0
⊢ a.castSucc.pred ha < a
state_after: no goals
tactic: rw [pred_castSucc_lt_iff, le_def]
Theorem: Fin.Ioi_eq_finset_subtype
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ Ioi a = Finset.fin n (Ioc (↑a) n)
state_after: case a
n : ℕ
a b a✝ : Fin n
⊢ a✝ ∈ Ioi a ↔ a✝ ∈ Finset.fin n (Ioc (↑a) n)
tactic: ext
state_before: case a
n : ℕ
a b a✝ : Fin n
⊢ a✝ ∈ Ioi a ↔ a✝ ∈ Finset.fin n (Ioc (↑a) n)
state_after: no goals
tactic: simp
Theorem: MultilinearMap.mkContinuousMultilinear_norm_le'
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'
f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)
C : ℝ
H : ∀ (m₁ : (i : ι) → E i) (m₂ : (i : ι') → E' i), ‖(f m₁) m₂‖ ≤ (C * ∏ i : ι, ‖m₁ i‖) * ∏ i : ι', ‖m₂ i‖
⊢ ‖f.mkContinuousMultilinear C H‖ ≤ max C 0
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'
f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)
C : ℝ
H : ∀ (m₁ : (i : ι) → E i) (m₂ : (i : ι') → E' i), ‖(f m₁) m₂‖ ≤ (C * ∏ i : ι, ‖m₁ i‖) * ∏ i : ι', ‖m₂ i‖
⊢ ‖{ toFun := fun m => (f m).mkContinuous (C * ∏ i : ι, ‖m i‖) ⋯, map_add' := ⋯, map_smul' := ⋯ }.mkContinuous (max C 0)
        ⋯‖ ≤
    max C 0
tactic: dsimp only [mkContinuousMultilinear]
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'
f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)
C : ℝ
H : ∀ (m₁ : (i : ι) → E i) (m₂ : (i : ι') → E' i), ‖(f m₁) m₂‖ ≤ (C * ∏ i : ι, ‖m₁ i‖) * ∏ i : ι', ‖m₂ i‖
⊢ ‖{ toFun := fun m => (f m).mkContinuous (C * ∏ i : ι, ‖m i‖) ⋯, map_add' := ⋯, map_smul' := ⋯ }.mkContinuous (max C 0)
        ⋯‖ ≤
    max C 0
state_after: no goals
tactic: exact mkContinuous_norm_le _ (le_max_right _ _) _
Theorem: Module.End.isRoot_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

Proof steps:
state_before: K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
⊢ (minpoly K f).IsRoot μ
state_after: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ (minpoly K f).IsRoot μ
tactic: rcases (Submodule.ne_bot_iff _).1 h with ⟨w, ⟨H, ne0⟩⟩
state_before: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ (minpoly K f).IsRoot μ
state_after: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ eval μ (minpoly K f) • w = 0
tactic: refine Or.resolve_right (smul_eq_zero.1 ?_) ne0
state_before: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ eval μ (minpoly K f) • w = 0
state_after: no goals
tactic: simp [← aeval_apply_of_hasEigenvector ⟨H, ne0⟩, minpoly.aeval K f]
Theorem: TypeVec.toSubtype'_of_subtype'
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
⊢ toSubtype' r ⊚ ofSubtype' r = id
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : Subtype_ r i
⊢ (toSubtype' r ⊚ ofSubtype' r) i x = id i x
tactic: ext i x
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : Subtype_ r i
⊢ (toSubtype' r ⊚ ofSubtype' r) i x = id i x
state_after: no goals
tactic: induction i
  <;> dsimp only [id, toSubtype', comp, ofSubtype'] at *
  <;> simp [Subtype.eta, *]
Theorem: Matroid.Indep.mapEmbedding
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hI : M.Indep I
f : α ↪ β
⊢ (M.mapEmbedding f).Indep (⇑f '' I)
state_after: no goals
tactic: simpa [preimage_image_eq I f.injective]
Theorem: CategoryTheory.Limits.Fork.IsLimit.homIso_symm_apply
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
f✝ g✝ : X✝ ⟶ Y✝
X Y : C
f g : X ⟶ Y
t : Fork f g
ht : IsLimit t
Z : C
k : Z ⟶ t.pt
⊢ (k ≫ t.ι) ≫ f = (k ≫ t.ι) ≫ g
state_after: no goals
tactic: simp only [Category.assoc, t.condition]
Theorem: SetTheory.PGame.grundyValue_eq_mex_left
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: G : PGame
⊢ G.grundyValue = mex fun i => (G.moveLeft i).grundyValue
state_after: no goals
tactic: rw [grundyValue]
Theorem: Ordinal.enum_le_enum
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
o o' : Ordinal.{u}
ho : o < type r
ho' : o' < type r
⊢ ¬r (enum r o' ho') (enum r o ho) ↔ o ≤ o'
state_after: no goals
tactic: rw [← @not_lt _ _ o' o, enum_lt_enum ho']
Theorem: locallyLipschitzOn_univ
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s t : Set α
f : α → β
⊢ LocallyLipschitzOn univ f ↔ LocallyLipschitz f
state_after: no goals
tactic: simp [LocallyLipschitzOn, LocallyLipschitz]
Theorem: CategoryTheory.zeroMul_inv
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
tactic: have : (prod.snd : A ⨯ I ⟶ I) = CartesianClosed.uncurry (t.to _) := by
      rw [← curry_eq_iff]
      apply t.hom_ext
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ t.to (A ⟹ I) ≫ (exp A).map (t.to (A ⨯ I)) = curry (𝟙 (A ⨯ I))
tactic: rw [this, ← uncurry_natural_right, ← eq_curry_iff]
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ t.to (A ⟹ I) ≫ (exp A).map (t.to (A ⨯ I)) = curry (𝟙 (A ⨯ I))
state_after: no goals
tactic: apply t.hom_ext
Theorem: CauSeq.lim_add
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ (const abv (f.lim + g.lim) - (f + g)).LimZero
state_after: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ (const abv f.lim - f + (const abv g.lim - g)).LimZero
tactic: rw [const_add, add_sub_add_comm]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ (const abv f.lim - f + (const abv g.lim - g)).LimZero
state_after: no goals
tactic: exact add_limZero (Setoid.symm (equiv_lim f)) (Setoid.symm (equiv_lim g))
Theorem: isRelPrime_of_no_nonunits_factors
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MonoidWithZero α
x y : α
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : α), ¬IsUnit z → z ≠ 0 → z ∣ x → ¬z ∣ y
⊢ IsRelPrime x y
state_after: α : Type u_1
inst✝ : MonoidWithZero α
x y : α
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : α), ¬IsUnit z → z ≠ 0 → z ∣ x → ¬z ∣ y
z : α
hx : z ∣ x
hy : z ∣ y
h : ¬IsUnit z
⊢ z ≠ 0
tactic: refine fun z hx hy ↦ by_contra fun h ↦ H z h ?_ hx hy
state_before: α : Type u_1
inst✝ : MonoidWithZero α
x y : α
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : α), ¬IsUnit z → z ≠ 0 → z ∣ x → ¬z ∣ y
z : α
hx : z ∣ x
hy : z ∣ y
h : ¬IsUnit z
⊢ z ≠ 0
state_after: α : Type u_1
inst✝ : MonoidWithZero α
x y : α
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : α), ¬IsUnit z → z ≠ 0 → z ∣ x → ¬z ∣ y
hx : 0 ∣ x
hy : 0 ∣ y
h : ¬IsUnit 0
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
inst✝ : MonoidWithZero α
x y : α
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : α), ¬IsUnit z → z ≠ 0 → z ∣ x → ¬z ∣ y
hx : 0 ∣ x
hy : 0 ∣ y
h : ¬IsUnit 0
⊢ False
state_after: no goals
tactic: exact nonzero ⟨zero_dvd_iff.1 hx, zero_dvd_iff.1 hy⟩
Theorem: List.Ico.eq_empty_iff
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m : ℕ
h : Ico n m = []
⊢ m - n = 0
state_after: no goals
tactic: rw [← length, h, List.length]
Theorem: Filter.eventuallyEq_univ
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
l : Filter α
⊢ s =ᶠ[l] univ ↔ s ∈ l
state_after: no goals
tactic: simp [eventuallyEq_set]
Theorem: Int.natCast_eq_zero
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑n = 0 ↔ n = 0
state_after: no goals
tactic: omega
Theorem: EMetric.diam_pos_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
⊢ 0 < diam s ↔ s.Nontrivial
state_after: no goals
tactic: simp only [pos_iff_ne_zero, Ne, diam_eq_zero_iff, Set.not_subsingleton_iff]
Theorem: MeasureTheory.NullMeasurableSet.left_of_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
s : Set α
t : Set β
h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)
ht : ν t ≠ 0
⊢ NullMeasurableSet s μ
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
s : Set α
t : Set β
h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)
ht : ν t ≠ 0
⊢ NullMeasurableSet (t ×ˢ s) (ν.prod μ)
tactic: refine .right_of_prod ?_ ht
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
s : Set α
t : Set β
h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)
ht : ν t ≠ 0
⊢ NullMeasurableSet (t ×ˢ s) (ν.prod μ)
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
s : Set α
t : Set β
h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)
ht : ν t ≠ 0
⊢ NullMeasurableSet (Prod.swap ⁻¹' s ×ˢ t) (ν.prod μ)
tactic: rw [← preimage_swap_prod]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
s : Set α
t : Set β
h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)
ht : ν t ≠ 0
⊢ NullMeasurableSet (Prod.swap ⁻¹' s ×ˢ t) (ν.prod μ)
state_after: no goals
tactic: exact h.preimage measurePreserving_swap.quasiMeasurePreserving
Theorem: iInf_inf
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ (⨅ x, f x) ⊓ a = ⨅ x, f x ⊓ a
state_after: no goals
tactic: rw [iInf_inf_eq, iInf_const]
Theorem: MeasureTheory.ComplexMeasure.singularPart_add_withDensity_rnDeriv_eq
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
⊢ c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
⊢ c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = (re c).toComplexMeasure (im c)
tactic: conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
⊢ c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = (re c).toComplexMeasure (im c)
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ ↑(c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ)) i = ↑((re c).toComplexMeasure (im c)) i
tactic: ext i hi : 1
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ ↑(c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ)) i = ↑((re c).toComplexMeasure (im c)) i
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ ↑(c.singularPart μ) i + ↑(μ.withDensityᵥ (c.rnDeriv μ)) i = { re := ↑(re c) i, im := ↑(im c) i }
tactic: rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ ↑(c.singularPart μ) i + ↑(μ.withDensityᵥ (c.rnDeriv μ)) i = { re := ↑(re c) i, im := ↑(im c) i }
state_after: case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ (↑(c.singularPart μ) i + ↑(μ.withDensityᵥ (c.rnDeriv μ)) i).re = { re := ↑(re c) i, im := ↑(im c) i }.re

case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : c.HaveLebesgueDecomposition μ
i : Set α
hi : MeasurableSet i
⊢ (↑(c.singularPart μ) i + ↑(μ.withDensityᵥ (c.rnDeriv μ)) i).im = { re := ↑(re c) i, im := ↑(im c) i }.im
tactic: apply Complex.ext
Theorem: MeasureTheory.Lp.norm_const
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
inst✝¹ : IsFiniteMeasure μ
c : E
inst✝ : NeZero μ
hp_zero : p ≠ 0
⊢ ‖(Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
inst✝¹ : IsFiniteMeasure μ
c : E
inst✝ : NeZero μ
hp_zero : p ≠ 0
this : μ ≠ 0
⊢ ‖(Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
tactic: have := NeZero.ne μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
inst✝¹ : IsFiniteMeasure μ
c : E
inst✝ : NeZero μ
hp_zero : p ≠ 0
this : μ ≠ 0
⊢ ‖(Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
inst✝¹ : IsFiniteMeasure μ
c : E
inst✝ : NeZero μ
hp_zero : p ≠ 0
this : μ ≠ 0
⊢ (↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)).toReal = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
tactic: rw [← Memℒp.toLp_const, Lp.norm_toLp, eLpNorm_const] <;> try assumption
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
inst✝¹ : IsFiniteMeasure μ
c : E
inst✝ : NeZero μ
hp_zero : p ≠ 0
this : μ ≠ 0
⊢ (↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)).toReal = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: no goals
tactic: rw [ENNReal.toReal_mul, ENNReal.coe_toReal, ← ENNReal.toReal_rpow, coe_nnnorm]
Theorem: map_nhds_subtype_val
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
p : X → Prop
s : Set X
x : ↑s
⊢ map Subtype.val (𝓝 x) = 𝓝[s] ↑x
state_after: no goals
tactic: rw [inducing_subtype_val.map_nhds_eq, Subtype.range_val]
Theorem: AddLocalization.addEquivOfQuotient_mk
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f) (mk x y) = f.mk' x y
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f) ((monoidOf S).mk' x y) = f.mk' x y
tactic: rw [mk_eq_monoidOf_mk'_apply]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f) ((monoidOf S).mk' x y) = f.mk' x y
state_after: no goals
tactic: exact mulEquivOfQuotient_mk' _ _
Theorem: legendreSym.eq_one_of_sq_sub_mul_sq_eq_zero'
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
ha : ↑a ≠ 0
x y : ZMod p
hx : x ≠ 0
hxy : x ^ 2 - ↑a * y ^ 2 = 0
⊢ legendreSym p a = 1
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
ha : ↑a ≠ 0
x y : ZMod p
hx : x ≠ 0
hxy : x ^ 2 - ↑a * y ^ 2 = 0
hy : y ≠ 0
⊢ legendreSym p a = 1
tactic: haveI hy : y ≠ 0 := by
    rintro rfl
    rw [zero_pow two_ne_zero, mul_zero, sub_zero, sq_eq_zero_iff] at hxy
    exact hx hxy
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
ha : ↑a ≠ 0
x y : ZMod p
hx : x ≠ 0
hxy : x ^ 2 - ↑a * y ^ 2 = 0
hy : y ≠ 0
⊢ legendreSym p a = 1
state_after: no goals
tactic: exact eq_one_of_sq_sub_mul_sq_eq_zero ha hy hxy
Theorem: jacobiTheta₂_conj
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
⊢ (starRingEnd ℂ) (jacobiTheta₂ z τ) = jacobiTheta₂ ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: z τ : ℂ
⊢ ∑' (a : ℤ), (starRingEnd ℂ) (jacobiTheta₂_term a (-z) τ) = jacobiTheta₂ ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
tactic: rw [← jacobiTheta₂_neg_left, jacobiTheta₂, conj_tsum]
state_before: z τ : ℂ
⊢ ∑' (a : ℤ), (starRingEnd ℂ) (jacobiTheta₂_term a (-z) τ) = jacobiTheta₂ ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: case e_f.h
z τ : ℂ
n : ℤ
⊢ (starRingEnd ℂ) (jacobiTheta₂_term n (-z) τ) = jacobiTheta₂_term n ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
tactic: congr 2 with n
state_before: case e_f.h
z τ : ℂ
n : ℤ
⊢ (starRingEnd ℂ) (jacobiTheta₂_term n (-z) τ) = jacobiTheta₂_term n ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: no goals
tactic: simp only [jacobiTheta₂_term, mul_neg, ← exp_conj, map_add, map_neg, map_mul, map_ofNat,
    conj_ofReal, conj_I, map_intCast, neg_mul, neg_neg, map_pow]
Theorem: IsRelPrime.prod_right_iff
File: Mathlib/RingTheory/Coprime/Lemmas.lean

Proof steps:
state_before: α : Type u_1
I : Type u_2
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
⊢ IsRelPrime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsRelPrime x (s i)
state_after: no goals
tactic: simpa only [isRelPrime_comm] using IsRelPrime.prod_left_iff (α := α)
Theorem: equivShrink_add
File: Mathlib/Logic/Small/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x + y) = (equivShrink α) x + (equivShrink α) y
state_after: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x + y) =
    (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x) + (equivShrink α).symm ((equivShrink α) y))
tactic: rw [Equiv.add_def]
state_before: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x + y) =
    (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x) + (equivShrink α).symm ((equivShrink α) y))
state_after: no goals
tactic: simp