ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finmap.mem_list_toFinmap
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
⊢ a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
state_after: case nil
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
⊢ a ∈ [].toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ []

case cons
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
x : Sigma β
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
⊢ a ∈ (x :: xs).toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ x :: xs
tactic: induction' xs with x xs
state_before: case cons
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
x : Sigma β
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
⊢ a ∈ (x :: xs).toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ x :: xs
state_after: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a ∈ (⟨fst_i, snd_i⟩ :: xs).toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ ⟨fst_i, snd_i⟩ :: xs
tactic: cases' x with fst_i snd_i
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a ∈ (⟨fst_i, snd_i⟩ :: xs).toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ ⟨fst_i, snd_i⟩ :: xs
state_after: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ (a = fst_i ∨ ∃ b, ⟨a, b⟩ ∈ xs) ↔ (a = fst_i ∧ ∃ x, HEq x snd_i) ∨ ∃ x, ⟨a, x⟩ ∈ xs
tactic: simp only [toFinmap_cons, *, exists_or, mem_cons, mem_insert, exists_and_left, Sigma.mk.inj_iff]
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ (a = fst_i ∨ ∃ b, ⟨a, b⟩ ∈ xs) ↔ (a = fst_i ∧ ∃ x, HEq x snd_i) ∨ ∃ x, ⟨a, x⟩ ∈ xs
state_after: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a = fst_i → ∃ x, HEq x snd_i
tactic: refine (or_congr_left <| and_iff_left_of_imp ?_).symm
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a = fst_i → ∃ x, HEq x snd_i
state_after: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
snd_i : β a
⊢ ∃ x, HEq x snd_i
tactic: rintro rfl
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ xs.toFinmap ↔ ∃ b, ⟨a, b⟩ ∈ xs
snd_i : β a
⊢ ∃ x, HEq x snd_i
state_after: no goals
tactic: simp only [exists_eq, heq_iff_eq]
Theorem: Ordinal.cof_sup_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ (sup f).cof ≤ #ι
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ (sup f).cof ≤ Cardinal.lift.{u, u} #ι
tactic: rw [← (#ι).lift_id]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ (sup f).cof ≤ Cardinal.lift.{u, u} #ι
state_after: no goals
tactic: exact cof_sup_le_lift H
Theorem: not_differentiableAt_abs_zero
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
⊢ ¬DifferentiableAt ℝ abs 0
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
⊢ False
tactic: intro h
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
⊢ False
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
h₁ : deriv abs 0 = 1
⊢ False
tactic: have h₁ : deriv abs (0 : ℝ) = 1 :=
    (uniqueDiffOn_Ici _ _ Set.left_mem_Ici).eq_deriv _ h.hasDerivAt.hasDerivWithinAt <|
      (hasDerivWithinAt_id _ _).congr_of_mem (fun _ h ↦ abs_of_nonneg h) Set.left_mem_Ici
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
h₁ : deriv abs 0 = 1
⊢ False
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
h₁ : deriv abs 0 = 1
h₂ : deriv abs 0 = -1
⊢ False
tactic: have h₂ : deriv abs (0 : ℝ) = -1 :=
    (uniqueDiffOn_Iic _ _ Set.right_mem_Iic).eq_deriv _ h.hasDerivAt.hasDerivWithinAt <|
      (hasDerivWithinAt_neg _ _).congr_of_mem (fun _ h ↦ abs_of_nonpos h) Set.right_mem_Iic
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : DifferentiableAt ℝ abs 0
h₁ : deriv abs 0 = 1
h₂ : deriv abs 0 = -1
⊢ False
state_after: no goals
tactic: linarith
Theorem: RCLike.realRingEquiv_apply
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = x
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = ↑(re x) + ↑(im x) * I
tactic: nth_rw 2 [← re_add_im x]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
x : K
⊢ ↑(re x) = ↑(re x) + ↑(im x) * I
state_after: no goals
tactic: simp [h]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
⊢ ∀ (x y : K),
    { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
      { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun x *
        { toFun := ⇑re, invFun := ofReal, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: simp [im_eq_zero h]
Theorem: Finsupp.neLocus_self_sub_left
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ (f - g).neLocus f = g.support
state_after: no goals
tactic: rw [neLocus_comm, neLocus_self_sub_right]
Theorem: Submodule.set_smul_eq_iSup
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ s • N = ⨆ a ∈ s, a • N
state_after: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p} = Set.Ici (⨆ a ∈ s, a • N)
tactic: refine Eq.trans (congrArg sInf ?_) csInf_Ici
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p} = Set.Ici (⨆ a ∈ s, a • N)
state_after: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄, r ∈ s → ∀ a ∈ N, r • a ∈ p} = {x | ∀ i ∈ s, i • N ≤ x}
tactic: simp_rw [← Set.Ici_def, iSup_le_iff, @forall_comm M]
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
inst✝⁴ : Monoid S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DistribMulAction S M
sR : Set R
s✝ : Set S
N✝ : Submodule R M
inst✝ : SMulCommClass S R M
s : Set S
N : Submodule R M
⊢ {p | ∀ ⦃r : S⦄, r ∈ s → ∀ a ∈ N, r • a ∈ p} = {x | ∀ i ∈ s, i • N ≤ x}
state_after: no goals
tactic: exact Set.ext fun _ => forall₂_congr (fun _ _ => Iff.symm map_le_iff_le_comap)
Theorem: closedEmbedding_update
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
ι : Type u_3
β : ι → Type u_4
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → TopologicalSpace (β i)
x : (i : ι) → β i
i : ι
inst✝ : ∀ (i : ι), T1Space (β i)
⊢ ClosedEmbedding (update x i)
state_after: case h₁
X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
ι : Type u_3
β : ι → Type u_4
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → TopologicalSpace (β i)
x : (i : ι) → β i
i : ι
inst✝ : ∀ (i : ι), T1Space (β i)
⊢ Continuous (update x i)

case h₂
X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
ι : Type u_3
β : ι → Type u_4
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → TopologicalSpace (β i)
x : (i : ι) → β i
i : ι
inst✝ : ∀ (i : ι), T1Space (β i)
⊢ Injective (update x i)

case h₃
X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
ι : Type u_3
β : ι → Type u_4
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → TopologicalSpace (β i)
x : (i : ι) → β i
i : ι
inst✝ : ∀ (i : ι), T1Space (β i)
⊢ IsClosedMap (update x i)
tactic: apply closedEmbedding_of_continuous_injective_closed
Theorem: Subgroup.index_eq_two_iff
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ H.index = 2 ↔ ∃ a, ∀ (b : G), Xor' (b * a ∈ H) (b ∈ H)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ (∃ x ∉ H, ∀ x_1 ∉ H, x_1⁻¹ * x ∈ H) ↔ ∃ a, ∀ (b : G), b * a ∈ H ↔ b ∉ H
tactic: simp only [index, Nat.card_eq_two_iff' ((1 : G) : G ⧸ H), ExistsUnique, inv_mem_iff,
    QuotientGroup.exists_mk, QuotientGroup.forall_mk, Ne, QuotientGroup.eq, mul_one,
    xor_iff_iff_not]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ (∃ x ∉ H, ∀ x_1 ∉ H, x_1⁻¹ * x ∈ H) ↔ ∃ a, ∀ (b : G), b * a ∈ H ↔ b ∉ H
state_after: case refine_1
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hba : b * a ∈ H
hb : b ∈ H
⊢ False

case refine_2
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hb : b ∉ H
⊢ b * a ∈ H

case refine_3
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
⊢ a ∉ H

case refine_4
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
b : G
hb : b ∉ H
⊢ b⁻¹ * a ∈ H
tactic: refine exists_congr fun a =>
    ⟨fun ha b => ⟨fun hba hb => ?_, fun hb => ?_⟩, fun ha => ⟨?_, fun b hb => ?_⟩⟩
Theorem: Finset.inter_right_comm
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
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₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ∩ s₃ ↔ x✝ ∈ s₁ ∩ s₃ ∩ s₂
state_after: no goals
tactic: simp only [mem_inter, and_right_comm]
Theorem: Multiset.noncommFoldr_eq_foldr
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
s : Multiset α
h : LeftCommutative f
b : β
⊢ noncommFoldr f s ⋯ b = foldr f h b s
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
h : LeftCommutative f
b : β
a✝ : List α
⊢ noncommFoldr f ⟦a✝⟧ ⋯ b = foldr f h b ⟦a✝⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
h : LeftCommutative f
b : β
a✝ : List α
⊢ noncommFoldr f ⟦a✝⟧ ⋯ b = foldr f h b ⟦a✝⟧
state_after: no goals
tactic: simp
Theorem: MeasureTheory.ae_le_set
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
⊢ (∀ᵐ (x : α) ∂μ, x ∈ s → x ∈ t) ↔ μ (s \ t) = 0
state_after: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
⊢ μ {a | a ∈ s ∧ a ∉ t} = 0 ↔ μ (s \ t) = 0
tactic: simp [ae_iff]
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
⊢ μ {a | a ∈ s ∧ a ∉ t} = 0 ↔ μ (s \ t) = 0
state_after: no goals
tactic: rfl
Theorem: finprod_eq_prod_plift_of_mulSupport_toFinset_subset
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
⊢ ∏ᶠ (i : α), f i = ∏ i ∈ s, f i.down
state_after: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
⊢ ∏ i ∈ ?hc.toFinset, f i.down = ∏ i ∈ s, f i.down

case hc
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
⊢ (mulSupport ((fun i => f i) ∘ PLift.down)).Finite
tactic: rw [finprod, dif_pos]
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
⊢ ∏ i ∈ ?hc.toFinset, f i.down = ∏ i ∈ s, f i.down

case hc
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
⊢ (mulSupport ((fun i => f i) ∘ PLift.down)).Finite
state_after: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
x : PLift α
x✝ : x ∈ s
hxf : x ∉ hf.toFinset
⊢ f x.down = 1
tactic: refine Finset.prod_subset hs fun x _ hxf => ?_
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : (mulSupport (f ∘ PLift.down)).Finite
s : Finset (PLift α)
hs : hf.toFinset ⊆ s
x : PLift α
x✝ : x ∈ s
hxf : x ∉ hf.toFinset
⊢ f x.down = 1
state_after: no goals
tactic: rwa [hf.mem_toFinset, nmem_mulSupport] at hxf
Theorem: MeasureTheory.Measure.singularPart_eq_self
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
⊢ μ.singularPart ν = μ ↔ μ ⟂ₘ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ μ.singularPart ν = μ ↔ μ ⟂ₘ ν
tactic: have h_dec := haveLebesgueDecomposition_add μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ μ.singularPart ν = μ ↔ μ ⟂ₘ ν
state_after: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = μ
⊢ μ ⟂ₘ ν

case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : μ ⟂ₘ ν
⊢ μ.singularPart ν = μ
tactic: refine ⟨fun h ↦ ?_, fun  h ↦ ?_⟩
Theorem: AddEquiv.ofLeftInverse_apply
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝¹ : Mul M
inst✝ : Mul N
S T : Subsemigroup M
f : M →ₙ* N
g : N → M
h : Function.LeftInverse g ⇑f
x : ↥f.srange
x' : M
hx' : f x' = ↑x
⊢ f (g ↑x) = ↑x
state_after: no goals
tactic: rw [← hx', h x']
Theorem: List.aemeasurable_sum
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
l : List (α → M)
hl : ∀ f ∈ l, AEMeasurable f μ
⊢ AEMeasurable (fun x => (map (fun f => f x) l).prod) μ
state_after: no goals
tactic: simpa only [← Pi.list_prod_apply] using l.aemeasurable_prod' hl
Theorem: nhds_left_sup_nhds_right
File: Mathlib/Topology/Order/LeftRight.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[≤] a ⊔ 𝓝[≥] a = 𝓝 a
state_after: no goals
tactic: rw [← nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
Theorem: ContinuousMap.Homotopy.prod_apply
File: Mathlib/Topology/Homotopy/Product.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
A : Type u_3
inst✝ : TopologicalSpace A
f₀ f₁ : C(A, α)
g₀ g₁ : C(A, β)
S : Set A
F : f₀.Homotopy f₁
G : g₀.Homotopy g₁
x : A
⊢ { toFun := fun t => (F t, G t), continuous_toFun := ⋯ }.toFun (0, x) = (f₀.prodMk g₀) x
state_after: no goals
tactic: simp only [prod_eval, Homotopy.apply_zero]
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
A : Type u_3
inst✝ : TopologicalSpace A
f₀ f₁ : C(A, α)
g₀ g₁ : C(A, β)
S : Set A
F : f₀.Homotopy f₁
G : g₀.Homotopy g₁
x : A
⊢ { toFun := fun t => (F t, G t), continuous_toFun := ⋯ }.toFun (1, x) = (f₁.prodMk g₁) x
state_after: no goals
tactic: simp only [prod_eval, Homotopy.apply_one]
Theorem: fderiv_sub_const
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ fderiv 𝕜 (fun y => f y - c) x = fderiv 𝕜 f x
state_after: no goals
tactic: simp only [sub_eq_add_neg, fderiv_add_const]
Theorem: Nat.divModEquiv_symm_apply
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
p : ℕ × Fin n
⊢ (fun a => (a / n, ↑a)) ((fun p => p.1 * n + ↑p.2) p) = p
state_after: m n✝ n : ℕ
inst✝ : NeZero n
p : ℕ × Fin n
⊢ ((fun a => (a / n, ↑a)) ((fun p => p.1 * n + ↑p.2) p)).1 = p.1
tactic: refine Prod.ext ?_ (Fin.ext <| Nat.mul_add_mod_of_lt p.2.is_lt)
state_before: m n✝ n : ℕ
inst✝ : NeZero n
p : ℕ × Fin n
⊢ ((fun a => (a / n, ↑a)) ((fun p => p.1 * n + ↑p.2) p)).1 = p.1
state_after: m n✝ n : ℕ
inst✝ : NeZero n
p : ℕ × Fin n
⊢ (p.1 * n + ↑p.2) / n = p.1
tactic: dsimp only
state_before: m n✝ n : ℕ
inst✝ : NeZero n
p : ℕ × Fin n
⊢ (p.1 * n + ↑p.2) / n = p.1
state_after: no goals
tactic: rw [Nat.add_comm, Nat.add_mul_div_right _ _ n.pos_of_neZero, Nat.div_eq_of_lt p.2.is_lt,
      Nat.zero_add]
Theorem: ContinuousMap.inseparable_coe
File: Mathlib/Topology/CompactOpen.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace T
K : Set X
U : Set Y
f g : C(X, Y)
⊢ Inseparable ⇑f ⇑g ↔ Inseparable f g
state_after: no goals
tactic: simp only [inseparable_iff_specializes_and, specializes_coe]
Theorem: Matroid.not_finiteRk
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.InfiniteRk
⊢ ¬M.FiniteRk
state_after: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
⊢ False
tactic: intro h
state_before: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
⊢ False
state_after: case intro
α : Type u_1
M✝ : Matroid α
B✝ B₁ B₂ : Set α
M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
B : Set α
hB : M.Base B
⊢ False
tactic: obtain ⟨B,hB⟩ := M.exists_base
state_before: case intro
α : Type u_1
M✝ : Matroid α
B✝ B₁ B₂ : Set α
M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
B : Set α
hB : M.Base B
⊢ False
state_after: no goals
tactic: exact hB.infinite hB.finite
Theorem: Orientation.oangle_smul_right_of_pos
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
r : ℝ
hr : 0 < r
⊢ o.oangle x (r • y) = o.oangle x y
state_after: no goals
tactic: simp [oangle, Complex.arg_real_mul _ hr]
Theorem: seminormFromBounded_is_norm_iff
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_zero : f 0 = 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
f_neg : ∀ (x : R), f (-x) = f x
⊢ (∀ (x : R), (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun x = 0 → x = 0) ↔ f ⁻¹' {0} = {0}
state_after: case refine_1
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_zero : f 0 = 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
f_neg : ∀ (x : R), f (-x) = f x
h0 : ∀ (x : R), (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun x = 0 → x = 0
⊢ f ⁻¹' {0} = {0}

case refine_2
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_zero : f 0 = 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
f_neg : ∀ (x : R), f (-x) = f x
h_ker : f ⁻¹' {0} = {0}
x : R
hx : (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun x = 0
⊢ x = 0
tactic: refine ⟨fun h0 ↦ ?_, fun h_ker x hx ↦ ?_⟩
Theorem: nhdsSet_singleton
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ 𝓝ˢ {x} = 𝓝 x
state_after: no goals
tactic: simp [nhdsSet]