tasksource/leandojo huggingface dataset:
Theorem: Qpf.Wequiv.abs'
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: cases x
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
h : Qpf.abs (PFunctor.W.dest x) = Qpf.abs (PFunctor.W.dest y)
⊢ Wequiv x y

tactic: cases y
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
y : PFunctor.W (P F)
a✝ : (P F).A
f✝ : PFunctor.B (P F) a✝ → WType (P F).B
h : Qpf.abs (PFunctor.W.dest (WType.mk a✝ f✝)) = Qpf.abs (PFunctor.W.dest y)
⊢ Wequiv (WType.mk a✝ f✝) y

tactic: apply Wequiv.abs
state_before: case mk.mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a✝¹ : (P F).A
f✝¹ : PFunctor.B (P F) a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : PFunctor.B (P F) a✝ → WType (P F).B
h : Qpf.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = Qpf.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ Wequiv (WType.mk a✝¹ f✝¹) (WType.mk a✝ f✝)

tactic: apply h
state_before: case mk.mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a✝¹ : (P F).A
f✝¹ : PFunctor.B (P F) a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : PFunctor.B (P F) a✝ → WType (P F).B
h : Qpf.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = Qpf.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ Qpf.abs { fst := a✝¹, snd := f✝¹ } = Qpf.abs { fst := a✝, snd := f✝ }
Theorem: FractionalIdeal.mem_div_iff_of_nonzero
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [div_nonzero h]
state_before: R : Type ?u.1194138
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1194345
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ I / J ↔ ∀ (y : K), y ∈ J → x * y ∈ I

tactic: exact Submodule.mem_div_iff_forall_mul_mem
state_before: R : Type ?u.1194138
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1194345
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ { val := ↑I / ↑J, property := (_ : IsFractional R₁⁰ (↑I / ↑J)) } ↔ ∀ (y : K), y ∈ J → x * y ∈ I
Theorem: Set.mulIndicator_union_mul_inter_apply
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: by_cases hs : a ∈ s <;> by_cases ht : a ∈ t <;> simp [*]
state_before: α : Type u_1
β : Type ?u.43706
ι : Type ?u.43709
M : Type u_2
N : Type ?u.43715
inst✝ : MulOneClass M
s✝ t✝ : Set α
f✝ g : α → M
a✝ : α
f : α → M
s t : Set α
a : α
⊢ mulIndicator (s ∪ t) f a * mulIndicator (s ∩ t) f a = mulIndicator s f a * mulIndicator t f a
Theorem: Ordnode.eraseMax.valid
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Valid.dual_iff, dual_eraseMax]
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : Valid t
⊢ Valid (eraseMax t)

tactic: exact eraseMin.valid h.dual
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : Valid t
⊢ Valid (eraseMin (dual t))
Theorem: Complex.cpow_nat_cast
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp
state_before: x : ℂ
⊢ x ^ ↑0 = x ^ 0

tactic: simp only [hx, pow_succ, Complex.zero_cpow (Nat.cast_ne_zero.2 (Nat.succ_ne_zero _)),
  MulZeroClass.zero_mul]
state_before: x : ℂ
n : ℕ
hx : x = 0
⊢ x ^ ↑(n + 1) = x ^ (n + 1)

tactic: simp [cpow_add, hx, pow_add, cpow_nat_cast x n]
state_before: x : ℂ
n : ℕ
hx : ¬x = 0
⊢ x ^ ↑(n + 1) = x ^ (n + 1)
Theorem: IsROrC.mul_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: apply ext <;> simp only [normSq_apply, isROrC_simps, map_add, mul_zero] <;> ring
state_before: K : Type u_1
E : Type ?u.5035191
inst✝ : IsROrC K
z : K
⊢ z * ↑(starRingEnd K) z = ↑(↑normSq z)
Theorem: List.scanr_cons
File: Mathlib/Data/List/Basic.lean

tactic: simp only [scanr, foldr, cons.injEq, and_true]
state_before: ι : Type ?u.247779
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
b : β
a : α
l : List α
⊢ scanr f b (a :: l) = foldr f b (a :: l) :: scanr f b l

tactic: induction l generalizing a with
| nil => rfl
| cons hd tl ih => simp only [foldr, ih]
state_before: ι : Type ?u.247779
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
b : β
a : α
l : List α
⊢ f a (foldr (fun a x => (f a x.fst, x.fst :: x.snd)) (b, []) l).fst = f a (foldr f b l)

tactic: rfl
state_before: case nil
ι : Type ?u.247779
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
b : β
a : α
⊢ f a (foldr (fun a x => (f a x.fst, x.fst :: x.snd)) (b, []) []).fst = f a (foldr f b [])

tactic: simp only [foldr, ih]
state_before: case cons
ι : Type ?u.247779
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
b : β
hd : α
tl : List α
ih : ∀ (a : α), f a (foldr (fun a x => (f a x.fst, x.fst :: x.snd)) (b, []) tl).fst = f a (foldr f b tl)
a : α
⊢ f a (foldr (fun a x => (f a x.fst, x.fst :: x.snd)) (b, []) (hd :: tl)).fst = f a (foldr f b (hd :: tl))
Theorem: thickenedIndicator_tendsto_indicator_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: have key := thickenedIndicatorAux_tendsto_indicator_closure δseq_lim E
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
⊢ Tendsto (fun n => ↑(thickenedIndicator (_ : 0 < δseq n) E)) atTop (𝓝 (indicator (closure E) fun x => 1))

tactic: rw [tendsto_pi_nhds] at *
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : Tendsto (fun n => thickenedIndicatorAux (δseq n) E) atTop (𝓝 (indicator (closure E) fun x => 1))
⊢ Tendsto (fun n => ↑(thickenedIndicator (_ : 0 < δseq n) E)) atTop (𝓝 (indicator (closure E) fun x => 1))

tactic: intro x
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : ∀ (x : α), Tendsto (fun i => thickenedIndicatorAux (δseq i) E x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))
⊢ ∀ (x : α),
    Tendsto (fun i => ↑(thickenedIndicator (_ : 0 < δseq i) E) x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))

tactic: rw [show indicator (closure E) (fun _ => (1 : ℝ≥0)) x =
      (indicator (closure E) (fun _ => (1 : ℝ≥0∞)) x).toNNReal
    by refine' (congr_fun (comp_indicator_const 1 ENNReal.toNNReal zero_toNNReal) x).symm]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : ∀ (x : α), Tendsto (fun i => thickenedIndicatorAux (δseq i) E x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))
x : α
⊢ Tendsto (fun i => ↑(thickenedIndicator (_ : 0 < δseq i) E) x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))

tactic: refine' Tendsto.comp (tendsto_toNNReal _) (key x)
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : ∀ (x : α), Tendsto (fun i => thickenedIndicatorAux (δseq i) E x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))
x : α
⊢ Tendsto (fun i => ↑(thickenedIndicator (_ : 0 < δseq i) E) x) atTop
    (𝓝 (ENNReal.toNNReal (indicator (closure E) (fun x => 1) x)))

tactic: by_cases x_mem : x ∈ closure E <;> simp [x_mem]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : ∀ (x : α), Tendsto (fun i => thickenedIndicatorAux (δseq i) E x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))
x : α
⊢ indicator (closure E) (fun x => 1) x ≠ ⊤

tactic: refine' (congr_fun (comp_indicator_const 1 ENNReal.toNNReal zero_toNNReal) x).symm
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δseq : ℕ → ℝ
δseq_pos : ∀ (n : ℕ), 0 < δseq n
δseq_lim : Tendsto δseq atTop (𝓝 0)
E : Set α
key : ∀ (x : α), Tendsto (fun i => thickenedIndicatorAux (δseq i) E x) atTop (𝓝 (indicator (closure E) (fun x => 1) x))
x : α
⊢ indicator (closure E) (fun x => 1) x = ENNReal.toNNReal (indicator (closure E) (fun x => 1) x)
Theorem: Pi.apply_mulSingle
File: Mathlib/Data/Pi/Algebra.lean

tactic: simpa only [Pi.one_apply, hf', mulSingle] using Function.apply_update f' 1 i x j
state_before: I : Type u
α : Type ?u.14053
β : Type ?u.14056
γ : Type ?u.14059
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
inst✝³ : DecidableEq I
inst✝² : (i : I) → One (f i)
inst✝¹ : (i : I) → One (g i)
inst✝ : (i : I) → One (h i)
f' : (i : I) → f i → g i
hf' : ∀ (i : I), f' i 1 = 1
i : I
x : f i
j : I
⊢ f' j (mulSingle i x j) = mulSingle i (f' i x) j
Theorem: Gamma_is_cong_sub
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: simp only [le_refl]
state_before: N✝ : ℕ
N : ℕ+
⊢ Gamma ↑N ≤ Gamma ↑N
Theorem: Nat.totient_lt
File: Mathlib/Data/Nat/Totient.lean

tactic: simp [hn.ne', pos_of_gt hn]
state_before: n : ℕ
hn : 1 < n
⊢ 0 ∈ range n ∧ ¬coprime n 0
Theorem: Function.Antiperiodic.div_inv
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [div_eq_mul_inv] using h.mul_const_inv ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.204600
f g : α → β
c c₁ c₂ x : α
inst✝¹ : DivisionSemiring α
inst✝ : Neg β
h : Antiperiodic f c
a : α
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (x / a)) (c * a)
Theorem: Finset.disjoint_filter_filter'
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [disjoint_left, mem_filter]
state_before: α : Type u_1
β : Type ?u.355965
γ : Type ?u.355968
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
⊢ _root_.Disjoint (filter p s) (filter q t)

tactic: rintro a ⟨_, hp⟩ ⟨_, hq⟩
state_before: α : Type u_1
β : Type ?u.355965
γ : Type ?u.355968
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
⊢ ∀ ⦃a : α⦄, a ∈ s ∧ p a → ¬(a ∈ t ∧ q a)

tactic: rw [Pi.disjoint_iff] at h
state_before: case intro.intro
α : Type u_1
β : Type ?u.355965
γ : Type ?u.355968
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False

tactic: simpa [hp, hq] using h a
state_before: case intro.intro
α : Type u_1
β : Type ?u.355965
γ : Type ?u.355968
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∀ (i : α), _root_.Disjoint (p i) (q i)
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False
Theorem: Order.pred_le_le_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine'
  ⟨fun h =>
    or_iff_not_imp_left.2 fun hba : b ≠ a => (le_pred_of_lt <| h.2.lt_of_ne hba).antisymm h.1, _⟩
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b✝ a b : α
⊢ pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b✝ a b : α
⊢ b = a ∨ b = pred a → pred a ≤ b ∧ b ≤ a

tactic: exact ⟨pred_le b, le_rfl⟩
state_before: case inl
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b✝ b : α
⊢ pred b ≤ b ∧ b ≤ b

tactic: exact ⟨le_rfl, pred_le a⟩
state_before: case inr
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b a : α
⊢ pred a ≤ pred a ∧ pred a ≤ a
Theorem: Filter.tendsto_const_mul_atBot_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [← mul_neg, ← tendsto_neg_atTop_iff] using tendsto_const_mul_atTop_of_pos hr
state_before: ι : Type ?u.226440
ι' : Type ?u.226443
α : Type u_1
β : Type u_2
γ : Type ?u.226452
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : 0 < r
⊢ Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atBot
Theorem: List.map_sub_range'
File: Std/Data/List/Lemmas.lean

tactic: conv => lhs; rw [← Nat.add_sub_cancel' h]
state_before: step a s n : Nat
h : a ≤ s
⊢ map (fun x => x - a) (range' s n step) = range' (s - a) n step

tactic: rw [← map_add_range', map_map, (?_ : _∘_ = _), map_id]
state_before: step a s n : Nat
h : a ≤ s
⊢ map (fun x => x - a) (range' (a + (s - a)) n step) = range' (s - a) n step

tactic: funext x
state_before: step a s n : Nat
h : a ≤ s
⊢ ((fun x => x - a) ∘ fun x => a + x) = id

tactic: apply Nat.add_sub_cancel_left
state_before: case h
step a s n : Nat
h : a ≤ s
x : Nat
⊢ ((fun x => x - a) ∘ fun x => a + x) x = id x
Theorem: Real.exp_approx_start
File: Mathlib/Data/Complex/Exponential.lean

tactic: simpa using h
state_before: x a b : ℝ
h : abs' (exp x - expNear 0 x a) ≤ abs' x ^ 0 / ↑(Nat.factorial 0) * b
⊢ abs' (exp x - a) ≤ b
Theorem: MeasureTheory.lintegral_mul_const''
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp_rw [mul_comm, lintegral_const_mul'' r hf]
state_before: α : Type u_1
β : Type ?u.945240
γ : Type ?u.945243
δ : Type ?u.945246
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f
⊢ (∫⁻ (a : α), f a * r ∂μ) = (∫⁻ (a : α), f a ∂μ) * r
Theorem: Fin.last_add_one
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only
state_before: n m : ℕ
⊢ last 0 + 1 = 0

tactic: ext
state_before: n✝ m n : ℕ
⊢ last (n + 1) + 1 = 0

tactic: rw [val_add, val_zero, val_last, val_one, Nat.mod_self]
state_before: case h
n✝ m n : ℕ
⊢ ↑(last (n + 1) + 1) = ↑0
Theorem: Rat.inv_coe_nat_num_of_pos
File: Mathlib/Data/Rat/Lemmas.lean

tactic: exact_mod_cast ha0
state_before: a : ℕ
ha0 : 0 < a
⊢ 0 < ↑a
Theorem: WithBot.preimage_coe_Ioi_bot
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← range_coe, preimage_range]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioi ⊥ = univ
Theorem: Complex.norm_max_aux₂
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: set e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
⊢ ‖f w‖ = ‖f z‖

tactic: have he : ∀ x, ‖e x‖ = ‖x‖ := UniformSpace.Completion.norm_coe
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
⊢ ‖f w‖ = ‖f z‖

tactic: replace hz : IsMaxOn (norm ∘ e ∘ f) (closedBall z (dist w z)) z
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
he : ∀ (x : F), ‖↑e x‖ = ‖x‖
⊢ ‖f w‖ = ‖f z‖
Theorem: Submonoid.LocalizationMap.mk'_mul_cancel_left
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_comm, mk'_mul_cancel_right]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.957542
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ mk' f (↑y * x) y = ↑(toMap f) x
Theorem: measurable_ciSup
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: change Measurable fun x => sSup (range fun i : ι => f i x)
state_before: α : Type u_3
β : Type ?u.1649128
γ : Type ?u.1649131
γ₂ : Type ?u.1649134
δ : Type u_2
ι✝ : Sort y
s t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : BorelSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : BorelSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : MeasurableSpace δ
inst✝³ : ConditionallyCompleteLinearOrder α
inst✝² : OrderTopology α
inst✝¹ : SecondCountableTopology α
ι : Type u_1
inst✝ : Countable ι
f : ι → δ → α
hf : ∀ (i : ι), Measurable (f i)
bdd : ∀ (x : δ), BddAbove (range fun i => f i x)
⊢ Measurable fun x => ⨆ (i : ι), f i x

tactic: simp_rw [← image_univ] at bdd⊢
state_before: α : Type u_3
β : Type ?u.1649128
γ : Type ?u.1649131
γ₂ : Type ?u.1649134
δ : Type u_2
ι✝ : Sort y
s t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : BorelSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : BorelSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : MeasurableSpace δ
inst✝³ : ConditionallyCompleteLinearOrder α
inst✝² : OrderTopology α
inst✝¹ : SecondCountableTopology α
ι : Type u_1
inst✝ : Countable ι
f : ι → δ → α
hf : ∀ (i : ι), Measurable (f i)
bdd : ∀ (x : δ), BddAbove (range fun i => f i x)
⊢ Measurable fun x => sSup (range fun i => f i x)

tactic: refine' measurable_cSup countable_univ hf bdd
state_before: α : Type u_3
β : Type ?u.1649128
γ : Type ?u.1649131
γ₂ : Type ?u.1649134
δ : Type u_2
ι✝ : Sort y
s t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : BorelSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : BorelSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : MeasurableSpace δ
inst✝³ : ConditionallyCompleteLinearOrder α
inst✝² : OrderTopology α
inst✝¹ : SecondCountableTopology α
ι : Type u_1
inst✝ : Countable ι
f : ι → δ → α
hf : ∀ (i : ι), Measurable (f i)
bdd : ∀ (x : δ), BddAbove ((fun i => f i x) '' univ)
⊢ Measurable fun x => sSup ((fun i => f i x) '' univ)
Theorem: ContinuousOpenMap.cancel_left
File: Mathlib/Topology/Hom/Open.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.17585
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.17597
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β →CO γ
f₁ f₂ : α →CO β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: EuclideanDomain.mul_div_cancel_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: have := mul_left_not_lt a h
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
a0 : a ≠ 0
h : ¬b - a * b / a = 0
⊢ False

tactic: rw [mul_sub, sub_eq_iff_eq_add'.2 (div_add_mod (a * b) a).symm] at this
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
a0 : a ≠ 0
h : ¬b - a * b / a = 0
this : ¬EuclideanDomain.r (a * (b - a * b / a)) a
⊢ False

tactic: exact this (mod_lt _ a0)
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
a0 : a ≠ 0
h : ¬b - a * b / a = 0
this : ¬EuclideanDomain.r (a * b % a) a
⊢ False
Theorem: RingQuot.Rel.sub_left
File: Mathlib/Algebra/RingQuot.lean

tactic: simp only [sub_eq_add_neg, h.add_left]
state_before: R✝ : Type u₁
inst✝⁴ : Semiring R✝
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
R : Type u₁
inst✝ : Ring R
r : R → R → Prop
a b c : R
h : Rel r a b
⊢ Rel r (a - c) (b - c)
Theorem: Computation.destruct_eq_think
File: Mathlib/Data/Seq/Computation.lean

tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s s' : Computation α
⊢ destruct s = Sum.inr s' → s = think s'

tactic: induction' f0 : s.1 0 with a' <;> intro h
state_before: α : Type u
β : Type v
γ : Type w
s s' : Computation α
⊢ (match ↑s 0 with
      | none => Sum.inr (tail s)
      | some a => Sum.inl a) =
      Sum.inr s' →
    s = think s'

tactic: injection h with h'
state_before: case none
α : Type u
β : Type v
γ : Type w
s s' : Computation α
x✝ : Option α
f0✝ : ↑s 0 = x✝
f0 : ↑s 0 = none
h :
  (match none with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inr s'
⊢ s = think s'

tactic: rw [← h']
state_before: case none
α : Type u
β : Type v
γ : Type w
s s' : Computation α
x✝ : Option α
f0✝ : ↑s 0 = x✝
f0 : ↑s 0 = none
h' : tail s = s'
⊢ s = think s'

tactic: cases' s with f al
state_before: case none
α : Type u
β : Type v
γ : Type w
s s' : Computation α
x✝ : Option α
f0✝ : ↑s 0 = x✝
f0 : ↑s 0 = none
h' : tail s = s'
⊢ s = think (tail s)

tactic: apply Subtype.eq
state_before: case none.mk
α : Type u
β : Type v
γ : Type w
s' : Computation α
x✝ : Option α
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
f0✝ : ↑{ val := f, property := al } 0 = x✝
f0 : ↑{ val := f, property := al } 0 = none
h' : tail { val := f, property := al } = s'
⊢ { val := f, property := al } = think (tail { val := f, property := al })

tactic: dsimp [think, tail]
state_before: case none.mk.a
α : Type u
β : Type v
γ : Type w
s' : Computation α
x✝ : Option α
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
f0✝ : ↑{ val := f, property := al } 0 = x✝
f0 : ↑{ val := f, property := al } 0 = none
h' : tail { val := f, property := al } = s'
⊢ ↑{ val := f, property := al } = ↑(think (tail { val := f, property := al }))

tactic: rw [← f0]
state_before: case none.mk.a
α : Type u
β : Type v
γ : Type w
s' : Computation α
x✝ : Option α
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
f0✝ : ↑{ val := f, property := al } 0 = x✝
f0 : ↑{ val := f, property := al } 0 = none
h' : tail { val := f, property := al } = s'
⊢ f = Stream'.cons none (Stream'.tail f)

tactic: exact (Stream'.eta f).symm
state_before: case none.mk.a
α : Type u
β : Type v
γ : Type w
s' : Computation α
x✝ : Option α
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
f0✝ : ↑{ val := f, property := al } 0 = x✝
f0 : ↑{ val := f, property := al } 0 = none
h' : tail { val := f, property := al } = s'
⊢ f = Stream'.cons (↑{ val := f, property := al } 0) (Stream'.tail f)

tactic: contradiction
state_before: case some
α : Type u
β : Type v
γ : Type w
s s' : Computation α
x✝ : Option α
f0✝ : ↑s 0 = x✝
a' : α
f0 : ↑s 0 = some a'
h :
  (match some a' with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inr s'
⊢ s = think s'
Theorem: Real.cos_pi_div_eight
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans cos (π / 2 ^ 3)
state_before: x : ℝ
⊢ cos (π / 8) = sqrt (2 + sqrt 2) / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 8) = cos (π / 2 ^ 3)

x : ℝ
⊢ cos (π / 2 ^ 3) = sqrt (2 + sqrt 2) / 2

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 8 = 2 ^ 3

x : ℝ
⊢ cos (π / 2 ^ 3) = sqrt (2 + sqrt 2) / 2

tactic: simp
state_before: x : ℝ
⊢ cos (π / 2 ^ 3) = sqrt (2 + sqrt 2) / 2
Theorem: ClosedEmbedding.closed_iff_image_closed
File: Mathlib/Topology/Maps.lean

tactic: rw [← preimage_image_eq s hf.inj]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.270791
δ : Type ?u.270794
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : ClosedEmbedding f
s : Set α
h : IsClosed (f '' s)
⊢ IsClosed s

tactic: exact h.preimage hf.continuous
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.270791
δ : Type ?u.270794
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : ClosedEmbedding f
s : Set α
h : IsClosed (f '' s)
⊢ IsClosed (f ⁻¹' (f '' s))
Theorem: Ultrafilter.finite_biUnion_mem_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [← sUnion_image, finite_sUnion_mem_iff (his.image s), bex_image_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.15563
f g : Ultrafilter α
s✝ t : Set α
p q : α → Prop
is : Set β
s : β → Set α
his : Set.Finite is
⊢ (⋃ (i : β) (_ : i ∈ is), s i) ∈ f ↔ ∃ i, i ∈ is ∧ s i ∈ f
Theorem: List.rdropWhile_concat_pos
File: Mathlib/Data/List/Rdrop.lean

tactic: rw [rdropWhile_concat, if_pos h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
h : p x = true
⊢ rdropWhile p (l ++ [x]) = rdropWhile p l