ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ZNum.dvd_to_int
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : ZNum
x✝ : ↑m ∣ ↑n
k : ℤ
e : ↑n = ↑m * k
⊢ n = m * ↑k
state_after: α : Type u_1
m n : ZNum
x✝ : ↑m ∣ ↑n
k : ℤ
e : ↑n = ↑m * k
⊢ ↑(↑m * k) = m * ↑k
tactic: rw [← of_to_int n, e]
state_before: α : Type u_1
m n : ZNum
x✝ : ↑m ∣ ↑n
k : ℤ
e : ↑n = ↑m * k
⊢ ↑(↑m * k) = m * ↑k
state_after: no goals
tactic: simp
state_before: α : Type u_1
m n : ZNum
x✝ : m ∣ n
k : ZNum
e : n = m * k
⊢ ↑n = ↑m * ↑k
state_after: no goals
tactic: simp [e]
Theorem: Filter.map_atTop_eq_of_gc
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
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
⊢ map f atTop = atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
⊢ atTop ≤ map f atTop
tactic: refine
    le_antisymm
      (hf.tendsto_atTop_atTop fun b => ⟨g (b ⊔ b'), le_sup_left.trans <| hgi _ le_sup_right⟩) ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
⊢ atTop ≤ map f atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
⊢ atTop ≤ ⨅ a, 𝓟 (f '' {a' | a ≤ a'})
tactic: rw [@map_atTop_eq _ _ ⟨g b'⟩]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
⊢ atTop ≤ ⨅ a, 𝓟 (f '' {a' | a ≤ a'})
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
a : α
b : β
hb : b ∈ Ici (f a ⊔ b')
⊢ b ∈ f '' {a' | a ≤ a'}
tactic: refine le_iInf fun a => iInf_le_of_le (f a ⊔ b') <| principal_mono.2 fun b hb => ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
a : α
b : β
hb : b ∈ Ici (f a ⊔ b')
⊢ b ∈ f '' {a' | a ≤ a'}
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
a : α
b : β
hb : f a ≤ b ∧ b' ≤ b
⊢ b ∈ f '' {a' | a ≤ a'}
tactic: rw [mem_Ici, sup_le_iff] at hb
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
g : β → α
b' : β
hf : Monotone f
gc : ∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b
hgi : ∀ b ≥ b', b ≤ f (g b)
a : α
b : β
hb : f a ≤ b ∧ b' ≤ b
⊢ b ∈ f '' {a' | a ≤ a'}
state_after: no goals
tactic: exact ⟨g b, (gc _ _ hb.2).1 hb.1, le_antisymm ((gc _ _ hb.2).2 le_rfl) (hgi _ hb.2)⟩
Theorem: Int.cast_inj
File: Mathlib/Data/Int/Cast/Lemmas.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : AddGroupWithOne α
inst✝ : CharZero α
m n : ℤ
⊢ ↑m = ↑n ↔ m = n
state_after: no goals
tactic: rw [← sub_eq_zero, ← cast_sub, cast_eq_zero, sub_eq_zero]
Theorem: Algebra.traceMatrix_reindex
File: Mathlib/RingTheory/Trace/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
κ' : Type u_7
b : Basis κ A B
f : κ ≃ κ'
⊢ traceMatrix A ⇑(b.reindex f) = (reindex f f) (traceMatrix A ⇑b)
state_after: case a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
κ' : Type u_7
b : Basis κ A B
f : κ ≃ κ'
x y : κ'
⊢ traceMatrix A (⇑(b.reindex f)) x y = (reindex f f) (traceMatrix A ⇑b) x y
tactic: ext (x y)
state_before: case a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
κ' : Type u_7
b : Basis κ A B
f : κ ≃ κ'
x y : κ'
⊢ traceMatrix A (⇑(b.reindex f)) x y = (reindex f f) (traceMatrix A ⇑b) x y
state_after: no goals
tactic: simp
Theorem: CategoryTheory.shiftFunctorAdd_inv_app_obj_of_induced
File: Mathlib/CategoryTheory/Shift/Induced.lean

Proof steps:
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
⊢ (shiftFunctorAdd D a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X
state_after: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X
tactic: letI := HasShift.induced F A s i
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X
state_after: no goals
tactic: simp only [ShiftMkCore.shiftFunctorAdd_eq, HasShift.Induced.add_inv_app_obj]
Theorem: mellinConvergent_of_isBigO_rpow
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b : ℝ
f : ℝ → E
s : ℂ
hfc : LocallyIntegrableOn f (Ioi 0) volume
hf_top : f =O[atTop] fun x => x ^ (-a)
hs_top : s.re < a
hf_bot : f =O[𝓝[>] 0] fun x => x ^ (-b)
hs_bot : b < s.re
⊢ MellinConvergent f s
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b : ℝ
f : ℝ → E
s : ℂ
hfc : LocallyIntegrableOn f (Ioi 0) volume
hf_top : f =O[atTop] fun x => x ^ (-a)
hs_top : s.re < a
hf_bot : f =O[𝓝[>] 0] fun x => x ^ (-b)
hs_bot : b < s.re
⊢ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) (Ioi 0) volume
tactic: rw [MellinConvergent,
    mellin_convergent_iff_norm Subset.rfl measurableSet_Ioi hfc.aestronglyMeasurable]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b : ℝ
f : ℝ → E
s : ℂ
hfc : LocallyIntegrableOn f (Ioi 0) volume
hf_top : f =O[atTop] fun x => x ^ (-a)
hs_top : s.re < a
hf_bot : f =O[𝓝[>] 0] fun x => x ^ (-b)
hs_bot : b < s.re
⊢ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) (Ioi 0) volume
state_after: no goals
tactic: exact mellin_convergent_of_isBigO_scalar hfc.norm hf_top.norm_left hs_top hf_bot.norm_left hs_bot
Theorem: Grp.uliftFunctor_map
File: Mathlib/Algebra/Category/Grp/Basic.lean

Proof steps:
state_before: X : Grp
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : Grp
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: Filter.mem_countableGenerate_iff
File: Mathlib/Order/Filter/CountableInter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
⊢ s ∈ countableGenerate g ↔ ∃ S ⊆ g, S.Countable ∧ ⋂₀ S ⊆ s
state_after: case mp
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
h : s ∈ countableGenerate g
⊢ ∃ S ⊆ g, S.Countable ∧ ⋂₀ S ⊆ s

case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
h : ∃ S ⊆ g, S.Countable ∧ ⋂₀ S ⊆ s
⊢ s ∈ countableGenerate g
tactic: constructor <;> intro h
state_before: case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
h : ∃ S ⊆ g, S.Countable ∧ ⋂₀ S ⊆ s
⊢ s ∈ countableGenerate g
state_after: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s
⊢ s ∈ countableGenerate g
tactic: rcases h with ⟨S, Sg, Sct, hS⟩
state_before: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s
⊢ s ∈ countableGenerate g
state_after: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s
⊢ ∀ s ∈ S, s ∈ countableGenerate g
tactic: refine mem_of_superset ((countable_sInter_mem Sct).mpr ?_) hS
state_before: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s
⊢ ∀ s ∈ S, s ∈ countableGenerate g
state_after: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s✝ : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s✝
s : Set α
H : s ∈ S
⊢ s ∈ countableGenerate g
tactic: intro s H
state_before: case mpr.intro.intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
s✝ : Set α
S : Set (Set α)
Sg : S ⊆ g
Sct : S.Countable
hS : ⋂₀ S ⊆ s✝
s : Set α
H : s ∈ S
⊢ s ∈ countableGenerate g
state_after: no goals
tactic: exact CountableGenerateSets.basic (Sg H)
Theorem: LinearMap.isUnit_iff_range_eq_top
File: Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ IsUnit f ↔ range f = ⊤
state_after: no goals
tactic: rw [isUnit_iff_ker_eq_bot, ker_eq_bot_iff_range_eq_top]
Theorem: ComputablePred.computable_iff_re_compl_re'
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
⊢ ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a
state_after: no goals
tactic: classical exact computable_iff_re_compl_re
Theorem: Matrix.det_smul_inv_vecMul_eq_cramer_transpose
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
b : n → α
h : IsUnit A.det
⊢ A.det • b ᵥ* A⁻¹ = Aᵀ.cramer b
state_after: no goals
tactic: rw [← A⁻¹.transpose_transpose, vecMul_transpose, transpose_nonsing_inv, ← det_transpose,
    Aᵀ.det_smul_inv_mulVec_eq_cramer _ (isUnit_det_transpose A h)]
Theorem: AddSubgroup.card_eq_iff_eq_top
File: Mathlib/Algebra/Group/Subgroup/Finite.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
H K : Subgroup G
inst✝ : Finite ↥H
h : H = ⊤
⊢ Nat.card ↥H = Nat.card G
state_after: no goals
tactic: simpa only [h] using card_top
Theorem: FirstOrder.Language.Theory.models_of_models_theory
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
h : ∀ φ ∈ T', T ⊨ᵇ φ
φ : L.Formula α
hφ : T' ⊨ᵇ φ
⊢ T ⊨ᵇ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
⊢ T ⊨ᵇ φ
tactic: simp only [models_sentence_iff] at h
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
⊢ T ⊨ᵇ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
tactic: intro M
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
hM : ↑M ⊨ T'
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
tactic: have hM : M ⊨ T' := T'.model_iff.2 (fun ψ hψ => h ψ hψ M)
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
hM : ↑M ⊨ T'
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
hM : ↑M ⊨ T'
M' : T'.ModelType := ModelType.mk ↑M
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
tactic: let M' : ModelType T' := ⟨M⟩
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
φ : L.Formula α
hφ : T' ⊨ᵇ φ
h : ∀ φ ∈ T', ∀ (M : T.ModelType), ↑M ⊨ φ
M : T.ModelType
hM : ↑M ⊨ T'
M' : T'.ModelType := ModelType.mk ↑M
⊢ ∀ (v : α → ↑M) (xs : Fin 0 → ↑M), BoundedFormula.Realize φ v xs
state_after: no goals
tactic: exact hφ M'
Theorem: Int.bodd_negOfNat
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: n : ℕ
⊢ (negOfNat n).bodd = n.bodd
state_after: case succ
n✝ : ℕ
⊢ (negOfNat (n✝ + 1)).bodd = !n✝.bodd
tactic: cases n <;> simp (config := {decide := true})
state_before: case succ
n✝ : ℕ
⊢ (negOfNat (n✝ + 1)).bodd = !n✝.bodd
state_after: no goals
tactic: rfl
Theorem: CircleIntegrable.out
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : ℂ → E
c : ℂ
R : ℝ
inst✝ : NormedSpace ℂ E
hf : CircleIntegrable f c R
⊢ IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : ℂ → E
c : ℂ
R : ℝ
inst✝ : NormedSpace ℂ E
hf : IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
tactic: simp only [CircleIntegrable, deriv_circleMap, intervalIntegrable_iff] at *
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : ℂ → E
c : ℂ
R : ℝ
inst✝ : NormedSpace ℂ E
hf : IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
state_after: case refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : ℂ → E
c : ℂ
R : ℝ
inst✝ : NormedSpace ℂ E
hf : IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ AEStronglyMeasurable (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (volume.restrict (Ι 0 (2 * π)))

case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : ℂ → E
c : ℂ
R : ℝ
inst✝ : NormedSpace ℂ E
hf : IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ ∀ᵐ (a : ℝ) ∂volume.restrict (Ι 0 (2 * π)), ‖(circleMap 0 R a * I) • f (circleMap c R a)‖ ≤ |R| * ‖f (circleMap c R a)‖
tactic: refine (hf.norm.const_mul |R|).mono' ?_ ?_
Theorem: MeasureTheory.continuous_diracProbaEquivSymm
File: Mathlib/MeasureTheory/Measure/DiracProba.lean

Proof steps:
state_before: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
⊢ Continuous ⇑diracProbaEquiv.symm
state_after: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
⊢ ∀ (x : ↑(range diracProba)), ContinuousAt (⇑diracProbaEquiv.symm) x
tactic: apply continuous_iff_continuousAt.mpr
state_before: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
⊢ ∀ (x : ↑(range diracProba)), ContinuousAt (⇑diracProbaEquiv.symm) x
state_after: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
μ : ↑(range diracProba)
⊢ ContinuousAt (⇑diracProbaEquiv.symm) μ
tactic: intro μ
state_before: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
μ : ↑(range diracProba)
⊢ ContinuousAt (⇑diracProbaEquiv.symm) μ
state_after: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
μ : ↑(range diracProba)
⊢ Tendsto (⇑diracProbaEquiv.symm) (𝓝 μ) (𝓝 (diracProbaInverse μ))
tactic: apply continuousAt_of_tendsto_nhds (y := diracProbaInverse μ)
state_before: X : Type u_1
inst✝⁴ : MeasurableSpace X
inst✝³ : TopologicalSpace X
inst✝² : OpensMeasurableSpace X
inst✝¹ : T0Space X
inst✝ : CompletelyRegularSpace X
μ : ↑(range diracProba)
⊢ Tendsto (⇑diracProbaEquiv.symm) (𝓝 μ) (𝓝 (diracProbaInverse μ))
state_after: no goals
tactic: exact (tendsto_diracProbaEquivSymm_iff_tendsto _).mpr fun _ mem_nhd ↦ mem_nhd
Theorem: Set.piecewise_insert_of_ne
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
i j : α
h : i ≠ j
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ (insert j s).piecewise f g i = s.piecewise f g i
state_after: no goals
tactic: simp [piecewise, h]
Theorem: CategoryTheory.Under.under_left
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X : T
U : Under X
⊢ U.left = { as := PUnit.unit }
state_after: no goals
tactic: simp only
Theorem: Fin.castSucc_pos'
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin n
h : 0 < i
⊢ 0 < i.castSucc
state_after: no goals
tactic: simpa [lt_iff_val_lt_val] using h
Theorem: Finset.Icc_subset_Ico_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Icc a b₁ ⊆ Ico a b₂
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Set.Icc a b₁ ⊆ Set.Ico a b₂
tactic: rw [← coe_subset, coe_Icc, coe_Ico]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Set.Icc a b₁ ⊆ Set.Ico a b₂
state_after: no goals
tactic: exact Set.Icc_subset_Ico_right h
Theorem: ProbabilityTheory.IndepFun.integrable_exp_mul_add
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
⊢ Integrable (fun ω => rexp (t * (X + Y) ω)) μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
⊢ Integrable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ
tactic: simp_rw [Pi.add_apply, mul_add, exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
⊢ Integrable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ
state_after: no goals
tactic: exact (h_indep.exp_mul t t).integrable_mul h_int_X h_int_Y
Theorem: Batteries.AssocList.toList_mapKey
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
δ : Type u_2
β : Type u_3
f : α → δ
l : AssocList α β
⊢ (mapKey f l).toList =
    List.map
      (fun x =>
        match x with
        | (a, b) => (f a, b))
      l.toList
state_after: no goals
tactic: induction l <;> simp [*]