ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.div_subset_range
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
⊢ s / t ⊆ range ⇑m
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x / x_1) a b ∈ range ⇑m
tactic: rintro _ ⟨a, ha, b, hb, rfl⟩
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x / x_1) a b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x / x_1) (m a) b ∈ range ⇑m
tactic: obtain ⟨a, rfl⟩ := hs ha
state_before: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x / x_1) (m a) b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x / x_1) (m a) (m b) ∈ range ⇑m
tactic: obtain ⟨b, rfl⟩ := ht hb
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x / x_1) (m a) (m b) ∈ range ⇑m
state_after: no goals
tactic: exact ⟨a / b, map_div _ _ _⟩
Theorem: Pi.single_apply_smul
File: Mathlib/Algebra/SMulWithZero.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
M : Type u_3
M' : Type u_4
inst✝⁷ : MonoidWithZero R
inst✝⁶ : MonoidWithZero R'
inst✝⁵ : Zero M
inst✝⁴ : MulActionWithZero R M
inst✝³ : Zero M'
inst✝² : SMul R M'
p : Prop
inst✝¹ : Decidable p
ι : Type u_5
inst✝ : DecidableEq ι
x : M
i j : ι
⊢ single i 1 j • x = single i x j
state_after: no goals
tactic: rw [single_apply, ite_smul, one_smul, zero_smul, single_apply]
Theorem: Monotone.frequently_le_map_of_frequently_le
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
⊢ ∃ᶠ (y : S) in map f F, y ≤ f u
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, ¬(fun y => y ≤ f u) x
⊢ ∀ᶠ (x : R) in F, ¬(fun x => x ≤ u) x
tactic: refine fun ev ↦ freq_le ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, ¬(fun y => y ≤ f u) x
⊢ ∀ᶠ (x : R) in F, ¬(fun x => x ≤ u) x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
⊢ ∀ᶠ (x : R) in F, u < x
tactic: simp only [not_le, not_lt] at ev freq_le ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
⊢ ∀ᶠ (x : R) in F, u < x
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
z : R
hz : z ∈ f ⁻¹' {x | f u < x}
⊢ u < z
tactic: filter_upwards [ev] with z hz
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
z : R
hz : z ∈ f ⁻¹' {x | f u < x}
⊢ u < z
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
z : R
hz : z ∈ f ⁻¹' {x | f u < x}
con : ¬u < z
⊢ False
tactic: by_contra con
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
u : R
freq_le : ∃ᶠ (x : R) in F, x ≤ u
ev : ∀ᶠ (x : S) in map f F, f u < x
z : R
hz : z ∈ f ⁻¹' {x | f u < x}
con : ¬u < z
⊢ False
state_after: no goals
tactic: apply lt_irrefl (f u) <| lt_of_lt_of_le hz <| f_incr (not_lt.mp con)
Theorem: compare_gt_iff_gt
File: Mathlib/Order/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.gt ↔ a > b
state_after: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ (if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) = Ordering.gt ↔ a > b
tactic: rw [LinearOrder.compare_eq_compareOfLessAndEq, compareOfLessAndEq]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ (if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) = Ordering.gt ↔ a > b
state_after: case neg
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : ¬a = b
⊢ True ↔ a > b
tactic: split_ifs <;> simp only [*, lt_irrefl, not_lt_of_gt]
state_before: case neg
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : ¬a = b
⊢ True ↔ a > b
state_after: no goals
tactic: case _ h₁ h₂ =>
    have h : b < a := lt_trichotomy a b |>.resolve_left h₁ |>.resolve_left h₂
    exact true_iff_iff.2 h
Theorem: injective_zsmul_iff_not_isOfFinAddOrder
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
⊢ (Injective fun n => x ^ n) ↔ ¬IsOfFinOrder x
state_after: case refine_1
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
⊢ (Injective fun n => x ^ n) → ¬IsOfFinOrder x

case refine_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : ¬IsOfFinOrder x
n m : ℤ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
tactic: refine ⟨?_, fun h n m hnm => ?_⟩
state_before: case refine_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : ¬IsOfFinOrder x
n m : ℤ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
state_after: no goals
tactic: rwa [zpow_eq_zpow_iff_modEq, orderOf_eq_zero_iff.2 h, Nat.cast_zero, Int.modEq_zero_iff] at hnm
Theorem: Ordinal.succ_log_def
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
⊢ succ (log b x) = sInf {o | x < b ^ o}
state_after: b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
⊢ succ (log b x) = sInf {o | x < b ^ o}
tactic: let t := sInf { o : Ordinal | x < b ^ o }
state_before: b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
⊢ succ (log b x) = sInf {o | x < b ^ o}
state_after: b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
this : x < b ^ t
⊢ succ (log b x) = sInf {o | x < b ^ o}
tactic: have : x < (b^t) := csInf_mem (log_nonempty hb)
state_before: b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
this : x < b ^ t
⊢ succ (log b x) = sInf {o | x < b ^ o}
state_after: case inl
b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
this : x < b ^ t
h : t = 0
⊢ succ (log b x) = sInf {o | x < b ^ o}

case inr.inl
b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
this : x < b ^ t
h : ∃ a, t = succ a
⊢ succ (log b x) = sInf {o | x < b ^ o}

case inr.inr
b x : Ordinal.{u_1}
hb : 1 < b
hx : x ≠ 0
t : Ordinal.{u_1} := sInf {o | x < b ^ o}
this : x < b ^ t
h : t.IsLimit
⊢ succ (log b x) = sInf {o | x < b ^ o}
tactic: rcases zero_or_succ_or_limit t with (h | h | h)
Theorem: RCLike.ofReal_lt_zero
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
x : ℝ
⊢ ↑x < 0 ↔ x < 0
state_after: no goals
tactic: rw [← ofReal_zero, ofReal_lt_ofReal]
Theorem: Multiset.inf_ndinsert
File: Mathlib/Data/Multiset/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ (ndinsert a s).inf = a ⊓ s.inf
state_after: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
tactic: rw [← inf_dedup, dedup_ext.2, inf_dedup, inf_cons]
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
state_after: no goals
tactic: simp
Theorem: StrictMono.add_le_nat
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ m + f n ≤ f (m + n)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ f n + m ≤ f (n + m)
tactic: rw [Nat.add_comm m, Nat.add_comm m]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ f n + m ≤ f (n + m)
state_after: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n : ℕ
⊢ f n + 0 ≤ f (n + 0)

case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n m : ℕ
ih : f n + m ≤ f (n + m)
⊢ f n + (m + 1) ≤ f (n + (m + 1))
tactic: induction' m with m ih
Theorem: HasStrictDerivAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

Proof steps:
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) (f' / f x) x
state_after: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') x
tactic: rw [div_eq_inv_mul]
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') x
state_after: no goals
tactic: exact (hasStrictDerivAt_log hx).comp x hf
Theorem: DFinsupp.card_Ico
File: Mathlib/Data/DFinsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → DecidableEq (α i)
inst✝² : (i : ι) → PartialOrder (α i)
inst✝¹ : (i : ι) → Zero (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
⊢ (Ico f g).card = ∏ i ∈ f.support ∪ g.support, (Icc (f i) (g i)).card - 1
state_after: no goals
tactic: rw [card_Ico_eq_card_Icc_sub_one, card_Icc]
Theorem: Multiset.le_sum_nonempty_of_subadditive
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → f (a * b) ≤ f a * f b
state_after: no goals
tactic: simp [h_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → (fun x => True) (a * b)
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ a ∈ s, (fun x => True) a
state_after: no goals
tactic: simp
Theorem: Complex.sameRay_iff_arg_div_eq_zero
File: Mathlib/Analysis/Complex/Arg.lean

Proof steps:
state_before: x y : ℂ
⊢ SameRay ℝ x y ↔ (x / y).arg = 0
state_after: x y : ℂ
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
tactic: rw [← Real.Angle.toReal_zero, ← arg_coe_angle_eq_iff_eq_toReal, sameRay_iff]
state_before: x y : ℂ
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: case pos
x y : ℂ
hx : x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

case neg
x y : ℂ
hx : ¬x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
tactic: by_cases hx : x = 0
state_before: case neg
x y : ℂ
hx : ¬x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: case pos
x y : ℂ
hx : ¬x = 0
hy : y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

case neg
x y : ℂ
hx : ¬x = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
tactic: by_cases hy : y = 0
state_before: case neg
x y : ℂ
hx : ¬x = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: no goals
tactic: simp [hx, hy, arg_div_coe_angle, sub_eq_zero]
Theorem: Set.Definable.inter
File: Mathlib/ModelTheory/Definability.lean

Proof steps:
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
hf : A.Definable L f
hg : A.Definable L g
⊢ A.Definable L (f ∩ g)
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s g : Set (α → M)
hg : A.Definable L g
φ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ g)
tactic: rcases hf with ⟨φ, rfl⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s g : Set (α → M)
hg : A.Definable L g
φ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ g)
state_after: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ setOf θ.Realize)
tactic: rcases hg with ⟨θ, rfl⟩
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ setOf θ.Realize)
state_after: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
⊢ setOf φ.Realize ∩ setOf θ.Realize = setOf (φ ⊓ θ).Realize
tactic: refine ⟨φ ⊓ θ, ?_⟩
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
⊢ setOf φ.Realize ∩ setOf θ.Realize = setOf (φ ⊓ θ).Realize
state_after: case intro.intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
x✝ : α → M
⊢ x✝ ∈ setOf φ.Realize ∩ setOf θ.Realize ↔ x✝ ∈ setOf (φ ⊓ θ).Realize
tactic: ext
state_before: case intro.intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
φ θ : L[[↑A]].Formula α
x✝ : α → M
⊢ x✝ ∈ setOf φ.Realize ∩ setOf θ.Realize ↔ x✝ ∈ setOf (φ ⊓ θ).Realize
state_after: no goals
tactic: simp
Theorem: Bornology.IsBounded.add
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
⊢ IsBounded (s * t)
state_after: case intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
⊢ IsBounded (s * t)
tactic: obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le'
state_before: case intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
⊢ IsBounded (s * t)
state_after: case intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
⊢ IsBounded (s * t)
tactic: obtain ⟨Rt, hRt⟩ : ∃ R, ∀ x ∈ t, ‖x‖ ≤ R := ht.exists_norm_le'
state_before: case intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
⊢ IsBounded (s * t)
state_after: case intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
⊢ ∀ x ∈ s * t, ‖x‖ ≤ Rs + Rt
tactic: refine isBounded_iff_forall_norm_le'.2 ⟨Rs + Rt, ?_⟩
state_before: case intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
⊢ ∀ x ∈ s * t, ‖x‖ ≤ Rs + Rt
state_after: case intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x✝ y✝ : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
x : E
hx : x ∈ s
y : E
hy : y ∈ t
⊢ ‖(fun x x_1 => x * x_1) x y‖ ≤ Rs + Rt
tactic: rintro z ⟨x, hx, y, hy, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝ : SeminormedGroup E
ε δ : ℝ
s t : Set E
x✝ y✝ : E
hs : IsBounded s
ht : IsBounded t
Rs : ℝ
hRs : ∀ x ∈ s, ‖x‖ ≤ Rs
Rt : ℝ
hRt : ∀ x ∈ t, ‖x‖ ≤ Rt
x : E
hx : x ∈ s
y : E
hy : y ∈ t
⊢ ‖(fun x x_1 => x * x_1) x y‖ ≤ Rs + Rt
state_after: no goals
tactic: exact norm_mul_le_of_le (hRs x hx) (hRt y hy)
Theorem: MeasureTheory.upperCrossingTime_mono
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
n m : ℕ
ω : Ω
hnm : n ≤ m
⊢ upperCrossingTime a b f N n ω ≤ upperCrossingTime a b f N m ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
n m : ℕ
ω : Ω
hnm : n ≤ m
⊢ Monotone fun n => upperCrossingTime a b f N n ω
tactic: suffices Monotone fun n => upperCrossingTime a b f N n ω by exact this hnm
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
n m : ℕ
ω : Ω
hnm : n ≤ m
⊢ Monotone fun n => upperCrossingTime a b f N n ω
state_after: no goals
tactic: exact monotone_nat_of_le_succ fun n =>
    le_trans upperCrossingTime_le_lowerCrossingTime lowerCrossingTime_le_upperCrossingTime_succ
Theorem: iteratedDerivWithin_zero
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDerivWithin 0 f s = f
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDerivWithin 0 f s x = f x
tactic: ext x
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDerivWithin 0 f s x = f x
state_after: no goals
tactic: simp [iteratedDerivWithin]
Theorem: Nat.primeFactors_mono
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
hmn : m ∣ n
hn : n ≠ 0
⊢ m.primeFactors ⊆ n.primeFactors
state_after: a b k m n p : ℕ
hmn : m ∣ n
hn : n ≠ 0
⊢ ∀ ⦃x : ℕ⦄, Prime x → x ∣ m → m ≠ 0 → Prime x ∧ x ∣ n ∧ n ≠ 0
tactic: simp only [subset_iff, mem_primeFactors, and_imp]
state_before: a b k m n p : ℕ
hmn : m ∣ n
hn : n ≠ 0
⊢ ∀ ⦃x : ℕ⦄, Prime x → x ∣ m → m ≠ 0 → Prime x ∧ x ∣ n ∧ n ≠ 0
state_after: no goals
tactic: exact fun p hp hpm _ ↦ ⟨hp, hpm.trans hmn, hn⟩
Theorem: norm_smul_le
File: Mathlib/Analysis/Normed/MulAction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : SeminormedAddGroup α
inst✝² : SeminormedAddGroup β
inst✝¹ : SMulZeroClass α β
inst✝ : BoundedSMul α β
r : α
x : β
⊢ ‖r • x‖ ≤ ‖r‖ * ‖x‖
state_after: no goals
tactic: simpa [smul_zero] using dist_smul_pair r 0 x