ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Batteries.AssocList.findEntryP?_eq
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ findEntryP? p l =
    List.find?
      (fun x =>
        match x with
        | (a, b) => p a b)
      l.toList
state_after: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  findEntryP? p tail✝ =
    List.find?
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (bif p key✝ value✝ then some (key✝, value✝) else findEntryP? p tail✝) =
    match p key✝ value✝ with
    | true => some (key✝, value✝)
    | false => List.find? (fun x => p x.fst x.snd) tail✝.toList
tactic: induction l <;> simp [findEntryP?, List.find?_cons]
state_before: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  findEntryP? p tail✝ =
    List.find?
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (bif p key✝ value✝ then some (key✝, value✝) else findEntryP? p tail✝) =
    match p key✝ value✝ with
    | true => some (key✝, value✝)
    | false => List.find? (fun x => p x.fst x.snd) tail✝.toList
state_after: no goals
tactic: split <;> simp [*]
Theorem: IsLowerSet.isUpperSet_preimage_coe
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 α
inst✝ : LE β
s t : Set α
a : α
hs : IsLowerSet s
⊢ IsUpperSet (Subtype.val ⁻¹' t) ↔ ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t
state_after: no goals
tactic: aesop
Theorem: Metric.hausdorffDist_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ hausdorffDist s ∅ = 0
state_after: case inl
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : s = ∅
⊢ hausdorffDist s ∅ = 0

case inr
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : s.Nonempty
⊢ hausdorffDist s ∅ = 0
tactic: rcases s.eq_empty_or_nonempty with h | h
Theorem: Finsupp.single_finset_sum
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ single a (∑ b ∈ s, f b) = ∑ b ∈ s, single a (f b)
state_after: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ single a (∑ b ∈ s, f b) = ?m.91772

α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ ?m.91772 = ∑ b ∈ s, single a (f b)

α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ α →₀ M
tactic: trans
Theorem: Real.Angle.toReal_eq_neg_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ θ.toReal = -π / 2 ↔ θ = ↑(-π / 2)
state_after: no goals
tactic: rw [← toReal_inj, toReal_neg_pi_div_two]
Theorem: Basis.flag_covBy
File: Mathlib/LinearAlgebra/Basis/Flag.lean

Proof steps:
state_before: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
b : Basis (Fin n) K V
i : Fin n
⊢ b.flag i.castSucc ⋖ b.flag i.succ
state_after: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
b : Basis (Fin n) K V
i : Fin n
⊢ b.flag i.castSucc ⋖ span K {b i} ⊔ b.flag i.castSucc
tactic: rw [flag_succ]
state_before: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
b : Basis (Fin n) K V
i : Fin n
⊢ b.flag i.castSucc ⋖ span K {b i} ⊔ b.flag i.castSucc
state_after: case h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
b : Basis (Fin n) K V
i : Fin n
⊢ b i ∉ b.flag i.castSucc
tactic: apply covBy_span_singleton_sup
state_before: case h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
b : Basis (Fin n) K V
i : Fin n
⊢ b i ∉ b.flag i.castSucc
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.restrict_singleton
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
a✝ : α
μ : Measure α
a : α
⊢ μ.restrict {a} = μ {a} • dirac a
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
a✝ : α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
⊢ (μ.restrict {a}) s = (μ {a} • dirac a) s
tactic: ext1 s hs
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
a✝ : α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
⊢ (μ.restrict {a}) s = (μ {a} • dirac a) s
state_after: case pos
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
a✝ : α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : a ∈ s
⊢ (μ.restrict {a}) s = (μ {a} • dirac a) s

case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
a✝ : α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : a ∉ s
⊢ (μ.restrict {a}) s = (μ {a} • dirac a) s
tactic: by_cases ha : a ∈ s
Theorem: Convex.cthickening
File: Mathlib/Analysis/Convex/Normed.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
hs : Convex ℝ s
δ : ℝ
⊢ Convex ℝ (Metric.cthickening δ s)
state_after: case inl
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
hs : Convex ℝ s
δ : ℝ
hδ : 0 ≤ δ
⊢ Convex ℝ (Metric.cthickening δ s)

case inr
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
hs : Convex ℝ s
δ : ℝ
hδ : δ ≤ 0
⊢ Convex ℝ (Metric.cthickening δ s)
tactic: obtain hδ | hδ := le_total 0 δ
Theorem: OmegaCompletePartialOrder.ContinuousHom.bind_apply
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α →𝒄 Part β
g : α →𝒄 β → Part γ
c : Chain α
⊢ ((↑f).partBind g.toOrderHom) (ωSup c) = ωSup (c.map ((↑f).partBind g.toOrderHom))
state_after: α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α →𝒄 Part β
g : α →𝒄 β → Part γ
c : Chain α
⊢ ((↑f).partBind ↑g) (ωSup c) = f (ωSup c) >>= g (ωSup c)
tactic: rw [ωSup_bind, ← f.continuous, g.toOrderHom_eq_coe, ← g.continuous]
state_before: α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α →𝒄 Part β
g : α →𝒄 β → Part γ
c : Chain α
⊢ ((↑f).partBind ↑g) (ωSup c) = f (ωSup c) >>= g (ωSup c)
state_after: no goals
tactic: rfl
Theorem: Sym.equivCongr_symm_apply
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
e : α ≃ β
x : Sym α n
⊢ map (⇑e.symm) (map (⇑e) x) = x
state_after: no goals
tactic: rw [map_map, Equiv.symm_comp_self, map_id]
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
e : α ≃ β
x : Sym β n
⊢ map (⇑e) (map (⇑e.symm) x) = x
state_after: no goals
tactic: rw [map_map, Equiv.self_comp_symm, map_id]
Theorem: exists_pos_left_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • x = y) ↔ SameRay R x y
state_after: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
h : ∃ r, 0 < r ∧ r • x = y
⊢ SameRay R x y
tactic: refine ⟨fun h => ?_, fun h => h.exists_pos_left hx hy⟩
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
h : ∃ r, 0 < r ∧ r • x = y
⊢ SameRay R x y
state_after: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
hy : r • x ≠ 0
⊢ SameRay R x (r • x)
tactic: rcases h with ⟨r, hr, rfl⟩
state_before: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
hy : r • x ≠ 0
⊢ SameRay R x (r • x)
state_after: no goals
tactic: exact SameRay.sameRay_pos_smul_right x hr
Theorem: Filter.extraction_forall_of_frequently
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
h : ∀ (n : ℕ), ∃ᶠ (k : ℕ) in atTop, P n k
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
h : ∀ (n a : ℕ), ∃ b > a, P n b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
tactic: simp only [frequently_atTop'] at h
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
h : ∀ (n a : ℕ), ∃ b > a, P n b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
tactic: choose u hu hu' using h
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
state_after: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ (StrictMono fun n => Nat.recOn n (u 0 0) fun n v => u (n + 1) v) ∧
    ∀ (n : ℕ), P n (Nat.recOn n (u 0 0) fun n v => u (n + 1) v)
tactic: use (fun n => Nat.recOn n (u 0 0) fun n v => u (n + 1) v : ℕ → ℕ)
state_before: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ (StrictMono fun n => Nat.recOn n (u 0 0) fun n v => u (n + 1) v) ∧
    ∀ (n : ℕ), P n (Nat.recOn n (u 0 0) fun n v => u (n + 1) v)
state_after: case h.left
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ StrictMono fun n => Nat.recOn n (u 0 0) fun n v => u (n + 1) v

case h.right
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → ℕ → Prop
u : ℕ → ℕ → ℕ
hu : ∀ (n a : ℕ), u n a > a
hu' : ∀ (n a : ℕ), P n (u n a)
⊢ ∀ (n : ℕ), P n (Nat.recOn n (u 0 0) fun n v => u (n + 1) v)
tactic: constructor
Theorem: CategoryTheory.Limits.Trident.mkHom_hom
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s t : Trident f
k : s.pt ⟶ t.pt
w : autoParam (k ≫ t.ι = s.ι) _auto✝
⊢ ∀ (j : WalkingParallelFamily J), k ≫ t.π.app j = s.π.app j
state_after: case zero
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s t : Trident f
k : s.pt ⟶ t.pt
w : autoParam (k ≫ t.ι = s.ι) _auto✝
⊢ k ≫ t.π.app zero = s.π.app zero

case one
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s t : Trident f
k : s.pt ⟶ t.pt
w : autoParam (k ≫ t.ι = s.ι) _auto✝
⊢ k ≫ t.π.app one = s.π.app one
tactic: rintro ⟨_ | _⟩
Theorem: ProbabilityTheory.IdentDistrib.integral_eq
File: Mathlib/Probability/IdentDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace γ
inst✝³ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝² : NormedAddCommGroup γ
inst✝¹ : NormedSpace ℝ γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
⊢ ∫ (x : α), f x ∂μ = ∫ (x : β), g x ∂ν
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace γ
inst✝³ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝² : NormedAddCommGroup γ
inst✝¹ : NormedSpace ℝ γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
hf : AEStronglyMeasurable f μ
⊢ ∫ (x : α), f x ∂μ = ∫ (x : β), g x ∂ν

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace γ
inst✝³ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝² : NormedAddCommGroup γ
inst✝¹ : NormedSpace ℝ γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
hf : ¬AEStronglyMeasurable f μ
⊢ ∫ (x : α), f x ∂μ = ∫ (x : β), g x ∂ν
tactic: by_cases hf : AEStronglyMeasurable f μ
Theorem: EuclideanGeometry.left_ne_right_of_oangle_sign_eq_one
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : (∡ p₁ p₂ p₃).sign = 1
⊢ 1 ≠ 0
state_after: no goals
tactic: decide
Theorem: Cardinal.cantor
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a : Cardinal.{u}
⊢ a < 2 ^ a
state_after: case h
α✝ β α : Type u
⊢ #α < 2 ^ #α
tactic: induction' a using Cardinal.inductionOn with α
state_before: case h
α✝ β α : Type u
⊢ #α < 2 ^ #α
state_after: case h
α✝ β α : Type u
⊢ #α < #(Set α)
tactic: rw [← mk_set]
state_before: case h
α✝ β α : Type u
⊢ #α < #(Set α)
state_after: case h
α✝ β α : Type u
⊢ ¬Quotient.liftOn₂ (#(Set α)) (#α) (fun α β => Nonempty (α ↪ β)) instLE.proof_1
tactic: refine ⟨⟨⟨singleton, fun a b => singleton_eq_singleton_iff.1⟩⟩, ?_⟩
state_before: case h
α✝ β α : Type u
⊢ ¬Quotient.liftOn₂ (#(Set α)) (#α) (fun α β => Nonempty (α ↪ β)) instLE.proof_1
state_after: case h.intro.mk
α✝ β α : Type u
f : Set α → α
hf : Injective f
⊢ False
tactic: rintro ⟨⟨f, hf⟩⟩
state_before: case h.intro.mk
α✝ β α : Type u
f : Set α → α
hf : Injective f
⊢ False
state_after: no goals
tactic: exact cantor_injective f hf
Theorem: Finset.piAntidiag_zero
File: Mathlib/Algebra/Order/Antidiag/Pi.lean

Proof steps:
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝³ : DecidableEq ι
inst✝² : CanonicallyOrderedAddCommMonoid μ
inst✝¹ : HasAntidiagonal μ
inst✝ : DecidableEq μ
s : Finset ι
⊢ s.piAntidiag 0 = {0}
state_after: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝³ : DecidableEq ι
inst✝² : CanonicallyOrderedAddCommMonoid μ
inst✝¹ : HasAntidiagonal μ
inst✝ : DecidableEq μ
s : Finset ι
a✝ : ι → μ
⊢ a✝ ∈ s.piAntidiag 0 ↔ a✝ ∈ {0}
tactic: ext
state_before: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝³ : DecidableEq ι
inst✝² : CanonicallyOrderedAddCommMonoid μ
inst✝¹ : HasAntidiagonal μ
inst✝ : DecidableEq μ
s : Finset ι
a✝ : ι → μ
⊢ a✝ ∈ s.piAntidiag 0 ↔ a✝ ∈ {0}
state_after: no goals
tactic: simp [Fintype.sum_eq_zero_iff_of_nonneg, funext_iff, not_imp_comm, ← forall_and]
Theorem: Finset.mulEnergy_eq_sum_sq'
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ Eₘ[s, t] =
    ∑ a ∈ s * t,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ∑ x ∈ s * t, (filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)).card
tactic: simp_rw [mulEnergy_eq_card_filter, sq, ← card_product]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ∑ x ∈ s * t, (filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)).card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card

case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)
tactic: rw [← card_disjiUnion]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card

case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)
state_after: case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)

α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card
tactic: swap
Theorem: Monoid.CoprodI.NeWord.of_word
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
w : Word M
h : w ≠ empty
⊢ ∃ i j w', w'.toWord = w
state_after: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
w : Word M
h : w ≠ empty
⊢ ∃ i j w', w'.toWord.toList = w.toList
tactic: suffices ∃ (i j : _) (w' : NeWord M i j), w'.toWord.toList = w.toList by
    rcases this with ⟨i, j, w, h⟩
    refine ⟨i, j, w, ?_⟩
    ext
    rw [h]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
w : Word M
h : w ≠ empty
⊢ ∃ i j w', w'.toWord.toList = w.toList
state_after: case mk
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1 : ∀ l_1 ∈ l, l_1.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h : { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', w'.toWord.toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList
tactic: cases' w with l hnot1 hchain
state_before: case mk
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1 : ∀ l_1 ∈ l, l_1.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h : { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', w'.toWord.toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList
state_after: case mk.nil
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
hnot1 : ∀ l ∈ [], l.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) []
h : { toList := [], ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', w'.toWord.toList = { toList := [], ne_one := hnot1, chain_ne := hchain }.toList

case mk.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
x : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ l_1 ∈ l, l_1.snd ≠ 1) (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l),
    { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', w'.toWord.toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1 : ∀ l_1 ∈ x :: l, l_1.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: l)
h : { toList := x :: l, ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', w'.toWord.toList = { toList := x :: l, ne_one := hnot1, chain_ne := hchain }.toList
tactic: induction' l with x l hi
Theorem: ArithmeticFunction.moebius_ne_zero_iff_eq_or
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
n : ℕ
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
state_after: R : Type u_1
n : ℕ
this : μ n = 0 ∨ μ n = 1 ∨ μ n = -1
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
tactic: have := moebius_eq_or n
state_before: R : Type u_1
n : ℕ
this : μ n = 0 ∨ μ n = 1 ∨ μ n = -1
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
state_after: no goals
tactic: aesop