ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rel.interedges_disjoint_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : Disjoint s s'
t : Finset β
⊢ Disjoint (interedges r s t) (interedges r s' t)
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s' t
tactic: rw [Finset.disjoint_left] at hs ⊢
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s' t
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s' t
⊢ False
tactic: intro _ hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s' t
⊢ False
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s' ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
⊢ False
tactic: rw [mem_interedges_iff] at hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s' ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
⊢ False
state_after: no goals
tactic: exact hs hx.1 hy.1
Theorem: LieModule.coe_weightSpaceOf_zero
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ ↑(weightSpaceOf M 0 x) = ⨆ k, LinearMap.ker ((toEnd R L M) x ^ k)
state_after: no goals
tactic: simp [weightSpaceOf, Module.End.maxGenEigenspace]
Theorem: Finset.map_sym_eq_piAntidiag
File: Mathlib/Algebra/Order/Antidiag/Pi.lean

Proof steps:
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
⊢ map { toFun := fun m a => Multiset.count a ↑m, inj' := ⋯ } (s.sym n) = s.piAntidiag n
state_after: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ f ∈ map { toFun := fun m a => Multiset.count a ↑m, inj' := ⋯ } (s.sym n) ↔ f ∈ s.piAntidiag n
tactic: ext f
state_before: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ f ∈ map { toFun := fun m a => Multiset.count a ↑m, inj' := ⋯ } (s.sym n) ↔ f ∈ s.piAntidiag n
state_after: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ (∃ s_1, (∀ a ∈ s_1, a ∈ s) ∧ Multiset.card s_1 = n ∧ ∀ (a : ι), Multiset.count a s_1 = f a) ↔
    s.sum f = n ∧ ∀ (i : ι), ¬f i = 0 → i ∈ s
tactic: simp only [Sym.val_eq_coe, mem_map, mem_sym_iff, Embedding.coeFn_mk, funext_iff, Sym.exists,
    Sym.mem_mk, Sym.coe_mk, exists_and_left, exists_prop, mem_piAntidiag, ne_eq]
state_before: case a
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ (∃ s_1, (∀ a ∈ s_1, a ∈ s) ∧ Multiset.card s_1 = n ∧ ∀ (a : ι), Multiset.count a s_1 = f a) ↔
    s.sum f = n ∧ ∀ (i : ι), ¬f i = 0 → i ∈ s
state_after: case a.mp
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ (∃ s_1, (∀ a ∈ s_1, a ∈ s) ∧ Multiset.card s_1 = n ∧ ∀ (a : ι), Multiset.count a s_1 = f a) →
    s.sum f = n ∧ ∀ (i : ι), ¬f i = 0 → i ∈ s

case a.mpr
ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
n : ℕ
f : ι → ℕ
⊢ (s.sum f = n ∧ ∀ (i : ι), ¬f i = 0 → i ∈ s) →
    ∃ s_1, (∀ a ∈ s_1, a ∈ s) ∧ Multiset.card s_1 = n ∧ ∀ (a : ι), Multiset.count a s_1 = f a
tactic: constructor
Theorem: Matroid.basis_restrict_iff
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hR : autoParam (R ⊆ M.E) _auto✝
⊢ (M ↾ R).Basis I X ↔ M.Basis I X ∧ X ⊆ R
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
hR : autoParam (R ⊆ M.E) _auto✝
⊢ X ⊆ R → (M.Basis I (X ∩ M.E) ↔ M.Basis I X)
tactic: rw [basis_restrict_iff', and_congr_left_iff]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hR : autoParam (R ⊆ M.E) _auto✝
⊢ X ⊆ R → (M.Basis I (X ∩ M.E) ↔ M.Basis I X)
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
hR : autoParam (R ⊆ M.E) _auto✝
hXR : X ⊆ R
⊢ M.Basis I (X ∩ M.E) ↔ M.Basis I X
tactic: intro hXR
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hR : autoParam (R ⊆ M.E) _auto✝
hXR : X ⊆ R
⊢ M.Basis I (X ∩ M.E) ↔ M.Basis I X
state_after: no goals
tactic: rw [← basis'_iff_basis_inter_ground, basis'_iff_basis]
Theorem: exists_lt_rieszContentAux_add_pos
File: Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
⊢ ∃ f, (∀ x ∈ K, 1 ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε
state_after: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ ∃ f, (∀ x ∈ K, 1 ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε
tactic: obtain ⟨α, ⟨⟨f, f_hyp⟩, α_hyp⟩⟩ :=
    exists_lt_of_csInf_lt (rieszContentAux_image_nonempty Λ K)
      (lt_add_of_pos_right (rieszContentAux Λ K) εpos)
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ ∃ f, (∀ x ∈ K, 1 ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε
state_after: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ Λ f < rieszContentAux Λ K + ε
tactic: refine ⟨f, f_hyp.left, ?_⟩
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ Λ f < rieszContentAux Λ K + ε
state_after: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ α < rieszContentAux Λ K + ε
tactic: rw [f_hyp.right]
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ x ∈ K, 1 ≤ f x} ∧ Λ f = α
⊢ α < rieszContentAux Λ K + ε
state_after: no goals
tactic: exact α_hyp
Theorem: Equiv.prod_assoc_preimage
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ⇑(prodAssoc α β γ) ⁻¹' s ×ˢ t ×ˢ u = (s ×ˢ t) ×ˢ u
state_after: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : (α × β) × γ
⊢ x✝ ∈ ⇑(prodAssoc α β γ) ⁻¹' s ×ˢ t ×ˢ u ↔ x✝ ∈ (s ×ˢ t) ×ˢ u
tactic: ext
state_before: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : (α × β) × γ
⊢ x✝ ∈ ⇑(prodAssoc α β γ) ⁻¹' s ×ˢ t ×ˢ u ↔ x✝ ∈ (s ×ˢ t) ×ˢ u
state_after: no goals
tactic: simp [and_assoc]
Theorem: Fin.insertNth_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (succAbove 0 j)
⊢ insertNth 0 x p = cons x fun j => _root_.cast ⋯ (p j)
state_after: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (succAbove 0 j)
⊢ p = removeNth 0 (cons x fun j => _root_.cast ⋯ (p j))
tactic: refine insertNth_eq_iff.2 ⟨by simp, ?_⟩
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (succAbove 0 j)
⊢ p = removeNth 0 (cons x fun j => _root_.cast ⋯ (p j))
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (succAbove 0 j)
j : Fin n
⊢ p j = removeNth 0 (cons x fun j => _root_.cast ⋯ (p j)) j
tactic: ext j
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (succAbove 0 j)
j : Fin n
⊢ p j = removeNth 0 (cons x fun j => _root_.cast ⋯ (p j)) j
state_after: no goals
tactic: convert (cons_succ x p j).symm
Theorem: innerDualCone_univ
File: Mathlib/Analysis/Convex/Cone/InnerDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ univ.innerDualCone = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ ∀ x ∈ univ.innerDualCone, x = 0
tactic: suffices ∀ x : H, x ∈ (univ : Set H).innerDualCone → x = 0 by
    apply SetLike.coe_injective
    exact eq_singleton_iff_unique_mem.mpr ⟨fun x _ => (inner_zero_right _).ge, this⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ ∀ x ∈ univ.innerDualCone, x = 0
state_after: no goals
tactic: exact fun x hx => by simpa [← real_inner_self_nonpos] using hx (-x) (mem_univ _)
Theorem: Cardinal.ofENat_le_one
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
⊢ ↑m ≤ 1 ↔ m ≤ 1
state_after: no goals
tactic: norm_cast
Theorem: Real.IsConjExponent.div_conj_eq_sub_one
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ
h : p.IsConjExponent q
⊢ p / q = p - 1
state_after: a b p q : ℝ
h : p.IsConjExponent q
⊢ p = (p - 1) * q
tactic: field_simp [h.symm.ne_zero]
state_before: a b p q : ℝ
h : p.IsConjExponent q
⊢ p = (p - 1) * q
state_after: no goals
tactic: rw [h.sub_one_mul_conj]
Theorem: Fin.succAbove_lt_iff_castSucc_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ p.succAbove i < p ↔ i.castSucc < p
state_after: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
H : i.castSucc < p
⊢ p.succAbove i < p ↔ i.castSucc < p

case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
H : p < i.succ
⊢ p.succAbove i < p ↔ i.castSucc < p
tactic: cases' castSucc_lt_or_lt_succ p i with H H
Theorem: equivShrink_symm_neg
File: Mathlib/Logic/Small/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm (-x) = -(equivShrink α).symm x
state_after: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm (-(equivShrink α).symm x)) = -(equivShrink α).symm x
tactic: rw [Equiv.neg_def]
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm (-(equivShrink α).symm x)) = -(equivShrink α).symm x
state_after: no goals
tactic: simp
Theorem: tendsto_intCast_atBot_iff
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto f l atBot
state_after: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto (Int.cast ∘ f) l atBot
tactic: rw [← @Int.comap_cast_atBot R, tendsto_comap_iff]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto (Int.cast ∘ f) l atBot
state_after: no goals
tactic: rfl
Theorem: add_self_div_two
File: Mathlib/Algebra/CharZero/Lemmas.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : DivisionSemiring R
inst✝ : NeZero 2
a : R
⊢ (a + a) / 2 = a
state_after: no goals
tactic: rw [← mul_two, mul_div_cancel_right₀ a two_ne_zero]
Theorem: normalClosure_eq_iSup_adjoin'
File: Mathlib/FieldTheory/NormalClosure.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)
tactic: have ⟨φ⟩ := ne
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F x)
tactic: refine h.toIsAlgebraic.of_injective φ φ.injective
    |>.normalClosure_eq_iSup_adjoin_of_splits fun x ↦ ?_
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F x)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F (φ x))
tactic: rw [← minpoly.algHom_eq _ φ.injective]
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F (φ x))
state_after: no goals
tactic: apply h.splits
Theorem: MeasureTheory.StronglyMeasurable.integral_kernel_prod_right''
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β × γ → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun x => ∫ (y : γ), f (x, y) ∂η (a, x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β × γ → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable ((fun x => ∫ (y : γ), (fun u => f (u.1.2, u.2)) (x, y) ∂η x) ∘ fun x => (a, x))
tactic: change
    StronglyMeasurable
      ((fun x => ∫ y, (fun u : (α × β) × γ => f (u.1.2, u.2)) (x, y) ∂η x) ∘ fun x => (a, x))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β × γ → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable ((fun x => ∫ (y : γ), (fun u => f (u.1.2, u.2)) (x, y) ∂η x) ∘ fun x => (a, x))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β × γ → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun x => ∫ (y : γ), (fun u => f (u.1.2, u.2)) (x, y) ∂η x
tactic: apply StronglyMeasurable.comp_measurable _ (measurable_prod_mk_left (m := mα))
Theorem: SimpleGraph.Walk.transfer_transfer
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u✝ v✝ u' v' : V
p✝ : G.Walk u✝ v✝
u v : V
p : G.Walk u v
H : SimpleGraph V
hp : ∀ e ∈ p.edges, e ∈ H.edgeSet
K : SimpleGraph V
hp' : ∀ e ∈ (p.transfer H hp).edges, e ∈ K.edgeSet
⊢ (p.transfer H hp).transfer K hp' = p.transfer K ⋯
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
    apply ih
Theorem: Dioph.diophFn_iff_pFun
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β γ : Type u
S S' : Set (α → ℕ)
f : (α → ℕ) → ℕ
⊢ DiophFn f = DiophPFun ↑f
state_after: α β γ : Type u
S S' : Set (α → ℕ)
f : (α → ℕ) → ℕ
v : Option α → ℕ
⊢ v ∈ {v | f (v ∘ some) = v none} ↔ v ∈ {v | (↑f).graph (v ∘ some, v none)}
tactic: refine congr_arg Dioph (Set.ext fun v => ?_)
state_before: α β γ : Type u
S S' : Set (α → ℕ)
f : (α → ℕ) → ℕ
v : Option α → ℕ
⊢ v ∈ {v | f (v ∘ some) = v none} ↔ v ∈ {v | (↑f).graph (v ∘ some, v none)}
state_after: no goals
tactic: exact PFun.lift_graph.symm
Theorem: ENNReal.lintegral_mul_prod_norm_pow_le
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∫⁻ (a : α), g a ^ q * ∏ i ∈ s, f i a ^ p i ∂μ ≤ (∫⁻ (a : α), g a ∂μ) ^ q * ∏ i ∈ s, (∫⁻ (a : α), f i a ∂μ) ^ p i
state_after: α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∫⁻ (t : α), ∏ j ∈ insertNone s, (j.elim (g t) fun j => f j t) ^ j.elim q p ∂μ ≤
    ∏ j ∈ insertNone s, (∫⁻ (t : α), j.elim (g t) fun j => f j t ∂μ) ^ j.elim q p
tactic: suffices
    ∫⁻ t, ∏ j ∈ insertNone s, Option.elim j (g t) (fun j ↦ f j t) ^ Option.elim j q p ∂μ
    ≤ ∏ j ∈ insertNone s, (∫⁻ t, Option.elim j (g t) (fun j ↦ f j t) ∂μ) ^ Option.elim j q p by
    simpa using this
state_before: α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∫⁻ (t : α), ∏ j ∈ insertNone s, (j.elim (g t) fun j => f j t) ^ j.elim q p ∂μ ≤
    ∏ j ∈ insertNone s, (∫⁻ (t : α), j.elim (g t) fun j => f j t ∂μ) ^ j.elim q p
state_after: case refine_1
α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∀ i ∈ insertNone s, AEMeasurable (fun t => i.elim (g t) fun j => f j t) μ

case refine_2
α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∑ i ∈ insertNone s, i.elim q p = 1

case refine_3
α✝ : Type u_1
inst✝¹ : MeasurableSpace α✝
μ✝ : Measure α✝
α : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
μ : Measure α
s : Finset ι
g : α → ℝ≥0∞
f : ι → α → ℝ≥0∞
hg : AEMeasurable g μ
hf : ∀ i ∈ s, AEMeasurable (f i) μ
q : ℝ
p : ι → ℝ
hpq : q + ∑ i ∈ s, p i = 1
hq : 0 ≤ q
hp : ∀ i ∈ s, 0 ≤ p i
⊢ ∀ i ∈ insertNone s, 0 ≤ i.elim q p
tactic: refine ENNReal.lintegral_prod_norm_pow_le _ ?_ ?_ ?_
Theorem: CategoryTheory.Kleisli.Adjunction.toKleisli_obj
File: Mathlib/CategoryTheory/Monad/Kleisli.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map f ≫
      { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    (f ≫ T.η.app Y) ≫ T.map (g ≫ T.η.app Z) ≫ T.μ.app Z
tactic: change _ = (f ≫ (Monad.η T).app Y) ≫ T.map (g ≫ (Monad.η T).app Z) ≫ T.μ.app Z
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    (f ≫ T.η.app Y) ≫ T.map (g ≫ T.η.app Z) ≫ T.μ.app Z
state_after: no goals
tactic: simp [← T.η.naturality g]
Theorem: Nat.Partrec.prec'
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: f g h : ℕ →. ℕ
hf : Partrec f
hg : Partrec g
hh : Partrec h
a s : ℕ
⊢ (s ∈
      (Seq.seq (Nat.pair <$> Part.some a) fun x => f a) >>=
        unpaired fun a n =>
          Nat.rec (g a)
            (fun y IH => do
              let i ← IH
              h (Nat.pair a (Nat.pair y i)))
            n) ↔
    s ∈
      (f a).bind fun n =>
        Nat.rec (g a)
          (fun y IH => do
            let i ← IH
            h (Nat.pair a (Nat.pair y i)))
          n
state_after: no goals
tactic: simp [Seq.seq]
Theorem: Multiset.powerset_cons
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
a : α
s : Multiset α
l : List α
⊢ (a ::ₘ ⟦l⟧).powerset = powerset ⟦l⟧ + map (cons a) (powerset ⟦l⟧)
state_after: no goals
tactic: simp [Function.comp_def]
Theorem: Turing.TM1to1.supportsStmt_write
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
l : List Bool
q : Stmt Bool Λ' σ
⊢ SupportsStmt S (write l q) = SupportsStmt S q
state_after: no goals
tactic: induction' l with _ l IH <;> simp only [write, SupportsStmt, *]