tasksource/leandojo huggingface dataset:
Theorem: Vector.get_set_eq_if
File: Mathlib/Data/Vector/Basic.lean

tactic: split_ifs <;> try simp [*] <;> try rw [get_set_of_ne] ; assumption
state_before: n : ℕ
α : Type u_1
β : Type ?u.60181
γ : Type ?u.60184
v : Vector α n
i j : Fin n
a : α
⊢ get (set v i a) j = if i = j then a else get v j

tactic: simp [*] <;> try rw [get_set_of_ne] ; assumption
state_before: case inr
n : ℕ
α : Type u_1
β : Type ?u.60181
γ : Type ?u.60184
v : Vector α n
i j : Fin n
a : α
h✝ : ¬i = j
⊢ get (set v i a) j = get v j

tactic: rw [get_set_of_ne]
state_before: case inr
n : ℕ
α : Type u_1
β : Type ?u.60181
γ : Type ?u.60184
v : Vector α n
i j : Fin n
a : α
h✝ : ¬i = j
⊢ get (set v i a) j = get v j

tactic: assumption
state_before: case inr.h
n : ℕ
α : Type u_1
β : Type ?u.60181
γ : Type ?u.60184
v : Vector α n
i j : Fin n
a : α
h✝ : ¬i = j
⊢ i ≠ j
Theorem: isLittleO_pow_const_mul_const_pow_const_pow_of_norm_lt
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: by_cases h0 : r₁ = 0
state_before: α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: rw [← Ne.def, ← norm_pos_iff] at h0
state_before: case neg
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : ¬r₁ = 0
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: have A : (fun n ↦ (n : R) ^ k : ℕ → R) =o[atTop] fun n ↦ (r₂ / ‖r₁‖) ^ n :=
  isLittleO_pow_const_const_pow_of_one_lt k ((one_lt_div h0).2 h)
state_before: case neg
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : 0 < ‖r₁‖
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: suffices (fun n ↦ r₁ ^ n) =O[atTop] fun n ↦ ‖r₁‖ ^ n by
  simpa [div_mul_cancel _ (pow_pos h0 _).ne'] using A.mul_isBigO this
state_before: case neg
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : 0 < ‖r₁‖
A : (fun n => ↑n ^ k) =o[atTop] fun n => (r₂ / ‖r₁‖) ^ n
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: exact IsBigO.of_bound 1 (by simpa using eventually_norm_pow_le r₁)
state_before: case neg
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : 0 < ‖r₁‖
A : (fun n => ↑n ^ k) =o[atTop] fun n => (r₂ / ‖r₁‖) ^ n
⊢ (fun n => r₁ ^ n) =O[atTop] fun n => ‖r₁‖ ^ n

tactic: refine' (isLittleO_zero _ _).congr' (mem_atTop_sets.2 <| ⟨1, fun n hn ↦ _⟩) EventuallyEq.rfl
state_before: case pos
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : r₁ = 0
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: simp [zero_pow (zero_lt_one.trans_le hn), h0]
state_before: case pos
α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : r₁ = 0
n : ℕ
hn : n ≥ 1
⊢ n ∈ {x | (fun x => (fun _x => 0) x = (fun n => ↑n ^ k * r₁ ^ n) x) x}

tactic: simpa [div_mul_cancel _ (pow_pos h0 _).ne'] using A.mul_isBigO this
state_before: α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : 0 < ‖r₁‖
A : (fun n => ↑n ^ k) =o[atTop] fun n => (r₂ / ‖r₁‖) ^ n
this : (fun n => r₁ ^ n) =O[atTop] fun n => ‖r₁‖ ^ n
⊢ (fun n => ↑n ^ k * r₁ ^ n) =o[atTop] fun n => r₂ ^ n

tactic: simpa using eventually_norm_pow_le r₁
state_before: α : Type ?u.98739
β : Type ?u.98742
ι : Type ?u.98745
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r₁ : R
r₂ : ℝ
h : ‖r₁‖ < r₂
h0 : 0 < ‖r₁‖
A : (fun n => ↑n ^ k) =o[atTop] fun n => (r₂ / ‖r₁‖) ^ n
⊢ ∀ᶠ (x : ℕ) in atTop, ‖r₁ ^ x‖ ≤ 1 * ‖‖r₁‖ ^ x‖
Theorem: iSup_bool_eq
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup, Bool.range_eq, sSup_pair, sup_comm]
state_before: α : Type u_1
β : Type ?u.162120
β₂ : Type ?u.162123
γ : Type ?u.162126
ι : Sort ?u.162129
ι' : Sort ?u.162132
κ : ι → Sort ?u.162137
κ' : ι' → Sort ?u.162142
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : Bool → α
⊢ (⨆ (b : Bool), f b) = f true ⊔ f false
Theorem: AffineSubspace.direction_affineSpan_insert
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [sup_comm, ← Set.union_singleton, ← coe_affineSpan_singleton k V p2]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p1 p2 : P
hp1 : p1 ∈ s
⊢ direction (affineSpan k (insert p2 ↑s)) = Submodule.span k {p2 -ᵥ p1} ⊔ direction s

tactic: change (s ⊔ affineSpan k {p2}).direction = _
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p1 p2 : P
hp1 : p1 ∈ s
⊢ direction (affineSpan k (↑s ∪ ↑(affineSpan k {p2}))) = direction s ⊔ Submodule.span k {p2 -ᵥ p1}

tactic: rw [direction_sup hp1 (mem_affineSpan k (Set.mem_singleton _)), direction_affineSpan]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p1 p2 : P
hp1 : p1 ∈ s
⊢ direction (s ⊔ affineSpan k {p2}) = direction s ⊔ Submodule.span k {p2 -ᵥ p1}

tactic: simp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p1 p2 : P
hp1 : p1 ∈ s
⊢ direction s ⊔ vectorSpan k {p2} ⊔ Submodule.span k {p2 -ᵥ p1} = direction s ⊔ Submodule.span k {p2 -ᵥ p1}
Theorem: Real.sin_eq_zero_iff_of_lt_of_lt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [h]
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x = 0
⊢ sin x = 0
Theorem: MeasureTheory.Memℒp.snorm_mk_lt_top
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [hfp.2]
state_before: α✝ : Type ?u.230952
E✝ : Type ?u.230955
F : Type ?u.230958
G : Type ?u.230961
m m0 : MeasurableSpace α✝
p✝ : ℝ≥0∞
q : ℝ
μ✝ ν : Measure α✝
inst✝⁴ : NormedAddCommGroup E✝
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
α : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
f : α → E
hfp : Memℒp f p
⊢ snorm (↑(AEEqFun.mk f (_ : AEStronglyMeasurable f μ))) p μ < ⊤
Theorem: Complex.rank_real_complex
File: Mathlib/Data/Complex/Module.lean

tactic: simp [← finrank_eq_rank, finrank_real_complex]
state_before: R : Type ?u.167857
S : Type ?u.167860
⊢ Module.rank ℝ ℂ = 2
Theorem: Filter.HasBasis.mem_lift_iff
File: Mathlib/Order/Filter/Lift.lean

tactic: refine' (mem_biInf_of_directed _ ⟨univ, univ_sets _⟩).trans _
state_before: α : Type u_2
β✝ : Type ?u.2792
γ : Type u_4
ι✝ : Sort ?u.2798
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Sort u_1
p : ι → Prop
s✝ : ι → Set α
f : Filter α
hf : HasBasis f p s✝
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s✝ i)) (pg i) (sg i)
gm : Monotone g
s : Set γ
⊢ s ∈ Filter.lift f g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s

tactic: intro t₁ ht₁ t₂ ht₂
state_before: case refine'_1
α : Type u_2
β✝ : Type ?u.2792
γ : Type u_4
ι✝ : Sort ?u.2798
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Sort u_1
p : ι → Prop
s✝ : ι → Set α
f : Filter α
hf : HasBasis f p s✝
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s✝ i)) (pg i) (sg i)
gm : Monotone g
s : Set γ
⊢ DirectedOn ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) f.sets

tactic: exact ⟨t₁ ∩ t₂, inter_mem ht₁ ht₂, gm <| inter_subset_left _ _, gm <| inter_subset_right _ _⟩
state_before: case refine'_1
α : Type u_2
β✝ : Type ?u.2792
γ : Type u_4
ι✝ : Sort ?u.2798
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Sort u_1
p : ι → Prop
s✝ : ι → Set α
f : Filter α
hf : HasBasis f p s✝
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s✝ i)) (pg i) (sg i)
gm : Monotone g
s : Set γ
t₁ : Set α
ht₁ : t₁ ∈ f.sets
t₂ : Set α
ht₂ : t₂ ∈ f.sets
⊢ ∃ z, z ∈ f.sets ∧ ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₁ z ∧ ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₂ z

tactic: simp only [← (hg _).mem_iff]
state_before: case refine'_2
α : Type u_2
β✝ : Type ?u.2792
γ : Type u_4
ι✝ : Sort ?u.2798
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Sort u_1
p : ι → Prop
s✝ : ι → Set α
f : Filter α
hf : HasBasis f p s✝
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s✝ i)) (pg i) (sg i)
gm : Monotone g
s : Set γ
⊢ (∃ i, i ∈ f.sets ∧ s ∈ g i) ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s

tactic: exact hf.exists_iff fun t₁ t₂ ht H => gm ht H
state_before: case refine'_2
α : Type u_2
β✝ : Type ?u.2792
γ : Type u_4
ι✝ : Sort ?u.2798
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Sort u_1
p : ι → Prop
s✝ : ι → Set α
f : Filter α
hf : HasBasis f p s✝
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s✝ i)) (pg i) (sg i)
gm : Monotone g
s : Set γ
⊢ (∃ i, i ∈ f.sets ∧ s ∈ g i) ↔ ∃ i, p i ∧ s ∈ g (s✝ i)
Theorem: Std.AssocList.mapVal_toList
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
f : α → β → δ
l : AssocList α β
⊢ toList (mapVal f l) =
    List.map
      (fun x =>
        match x with
        | (a, b) => (a, f a b))
      (toList l)
Theorem: Ideal.pow_sup_eq_top
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [← Finset.card_range n, ← Finset.prod_const]
state_before: R : Type u
ι : Type ?u.281942
inst✝ : CommSemiring R
I J K L : Ideal R
n : ℕ
h : I ⊔ J = ⊤
⊢ I ^ n ⊔ J = ⊤

tactic: exact prod_sup_eq_top fun _ _ => h
state_before: R : Type u
ι : Type ?u.281942
inst✝ : CommSemiring R
I J K L : Ideal R
n : ℕ
h : I ⊔ J = ⊤
⊢ (∏ _x in Finset.range n, I) ⊔ J = ⊤
Theorem: decide_eq_true_iff
File: Std/Logic.lean

tactic: simp
state_before: p : Prop
inst✝ : Decidable p
⊢ decide p = true ↔ p
Theorem: div_pow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_pow, inv_pow]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionCommMonoid α
a b : α
n : ℕ
⊢ (a / b) ^ n = a ^ n / b ^ n
Theorem: Antitone.ne_of_lt_of_lt_int
File: Mathlib/Order/Monotone/Basic.lean

tactic: rintro rfl
state_before: ι : Type ?u.46031
α : Type u
β : Type v
γ : Type w
δ : Type ?u.46040
π : ι → Type ?u.46045
r : α → α → Prop
inst✝ : Preorder α
f : ℤ → α
hf : Antitone f
n : ℤ
x : α
h1 : f (n + 1) < x
h2 : x < f n
a : ℤ
⊢ f a ≠ x

tactic: exact (hf.reflect_lt h2).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h1)
state_before: ι : Type ?u.46031
α : Type u
β : Type v
γ : Type w
δ : Type ?u.46040
π : ι → Type ?u.46045
r : α → α → Prop
inst✝ : Preorder α
f : ℤ → α
hf : Antitone f
n a : ℤ
h1 : f (n + 1) < f a
h2 : f a < f n
⊢ False
Theorem: continuous_prod_of_continuous_lipschitz
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simp only [continuous_iff_continuousOn_univ, ← univ_prod_univ, ← lipschitz_on_univ] at *
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoEMetricSpace γ
f : α × β → γ
K : ℝ≥0
ha : ∀ (a : α), Continuous fun y => f (a, y)
hb : ∀ (b : β), LipschitzWith K fun x => f (x, b)
⊢ Continuous f

tactic: exact continuousOn_prod_of_continuousOn_lipschitz_on f K (fun a _ => ha a) fun b _ => hb b
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoEMetricSpace γ
f : α × β → γ
K : ℝ≥0
ha : ∀ (a : α), ContinuousOn (fun y => f (a, y)) univ
hb : ∀ (b : β), LipschitzOnWith K (fun x => f (x, b)) univ
⊢ ContinuousOn f (univ ×ˢ univ)
Theorem: Filter.top_pow
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rw [pow_succ, top_pow n.succ_ne_zero, top_mul_top]
state_before: F : Type ?u.268989
α : Type u_1
β : Type ?u.268995
γ : Type ?u.268998
δ : Type ?u.269001
ε : Type ?u.269004
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ n : ℕ
x✝ : n + 2 ≠ 0
⊢ ⊤ ^ (n + 2) = ⊤
Theorem: ZFSet.toSet_sep
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: a : ZFSet
p : ZFSet → Prop
⊢ toSet (ZFSet.sep p a) = {x | x ∈ toSet a ∧ p x}

tactic: simp
state_before: case h
a : ZFSet
p : ZFSet → Prop
x✝ : ZFSet
⊢ x✝ ∈ toSet (ZFSet.sep p a) ↔ x✝ ∈ {x | x ∈ toSet a ∧ p x}
Theorem: Sum.update_elim_inl
File: Mathlib/Data/Sum/Basic.lean

tactic: simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.13935
inst✝¹ : DecidableEq α
inst✝ : DecidableEq (α ⊕ β)
f : α → γ
g : β → γ
i : α
x : γ
⊢ x = Sum.elim (update f i x) g (inl i)

tactic: simp (config := { contextual := true })
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.13935
inst✝¹ : DecidableEq α
inst✝ : DecidableEq (α ⊕ β)
f : α → γ
g : β → γ
i : α
x : γ
⊢ ∀ (x_1 : α ⊕ β), x_1 ≠ inl i → Sum.elim f g x_1 = Sum.elim (update f i x) g x_1
Theorem: Wbtw.swap_left_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [← wbtw_swap_left_iff R z, and_iff_right h]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.215069
P : Type u_3
P' : Type ?u.215075
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
h : Wbtw R x y z
⊢ Wbtw R y x z ↔ x = y
Theorem: MeasureTheory.ae_nonneg_restrict_of_forall_set_integral_nonneg_inter
File: Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean

tactic: refine' ae_nonneg_of_forall_set_integral_nonneg hf fun s hs h's => _
state_before: α : Type u_1
E : Type ?u.81134
m m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f✝ f : α → ℝ
t : Set α
hf : IntegrableOn f t
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
⊢ 0 ≤ᵐ[Measure.restrict μ t] f

tactic: simp_rw [Measure.restrict_restrict hs]
state_before: α : Type u_1
E : Type ?u.81134
m m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f✝ f : α → ℝ
t : Set α
hf : IntegrableOn f t
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
s : Set α
hs : MeasurableSet s
h's : ↑↑(Measure.restrict μ t) s < ⊤
⊢ 0 ≤ ∫ (x : α) in s, f x ∂Measure.restrict μ t

tactic: apply hf_zero s hs
state_before: α : Type u_1
E : Type ?u.81134
m m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f✝ f : α → ℝ
t : Set α
hf : IntegrableOn f t
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
s : Set α
hs : MeasurableSet s
h's : ↑↑(Measure.restrict μ t) s < ⊤
⊢ 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ

tactic: rwa [Measure.restrict_apply hs] at h's
state_before: α : Type u_1
E : Type ?u.81134
m m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f✝ f : α → ℝ
t : Set α
hf : IntegrableOn f t
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
s : Set α
hs : MeasurableSet s
h's : ↑↑(Measure.restrict μ t) s < ⊤
⊢ ↑↑μ (s ∩ t) < ⊤
Theorem: GeneralizedContinuedFraction.of_s_of_int
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: intro n
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a : ℤ
⊢ ∀ (n : ℕ), Stream'.Seq.get? (of ↑a).s n = none

tactic: induction' n with n ih
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n✝ : ℕ
a : ℤ
n : ℕ
⊢ Stream'.Seq.get? (of ↑a).s n = none

tactic: rw [of_s_head_aux, stream_succ_of_int, Option.bind]
state_before: case zero
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a : ℤ
⊢ Stream'.Seq.get? (of ↑a).s Nat.zero = none

tactic: exact (of (a : K)).s.prop ih
state_before: case succ
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n✝ : ℕ
a : ℤ
n : ℕ
ih : Stream'.Seq.get? (of ↑a).s n = none
⊢ Stream'.Seq.get? (of ↑a).s (Nat.succ n) = none
Theorem: CategoryTheory.Bicategory.whiskerLeft_iff
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η θ : f ⟶ g
⊢ 𝟙 a ◁ η = 𝟙 a ◁ θ ↔ η = θ
Theorem: Bool.not_false
File: src/lean/Init/SimpLemmas.lean

tactic: decide
state_before: ⊢ (!false) = true
Theorem: hasDerivWithinAt_iff_tendsto_slope'
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

tactic: rw [hasDerivWithinAt_iff_tendsto_slope, diff_singleton_eq_self hs]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : ¬x ∈ s
⊢ HasDerivWithinAt f f' s x ↔ Tendsto (slope f x) (𝓝[s] x) (𝓝 f')
Theorem: homology.comp_right_eq_comp_left
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simp only [Arrow.comp_left, Arrow.comp_right, p₁, p₂]
state_before: ι : Type ?u.130781
V✝ : Type u
inst✝²⁰ : Category V✝
inst✝¹⁹ : HasZeroMorphisms V✝
A B C : V✝
f : A ⟶ B
inst✝¹⁸ : HasImage f
g : B ⟶ C
inst✝¹⁷ : HasKernel g
w : f ≫ g = 0
A' B' C' : V✝
f' : A' ⟶ B'
inst✝¹⁶ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁵ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹⁴ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁✝ B₁✝ C₁✝ : V✝
f₁✝ : A₁✝ ⟶ B₁✝
inst✝¹³ : HasImage f₁✝
g₁✝ : B₁✝ ⟶ C₁✝
inst✝¹² : HasKernel g₁✝
w₁ : f₁✝ ≫ g₁✝ = 0
A₂✝ B₂✝ C₂✝ : V✝
f₂✝ : A₂✝ ⟶ B₂✝
inst✝¹¹ : HasImage f₂✝
g₂✝ : B₂✝ ⟶ C₂✝
inst✝¹⁰ : HasKernel g₂✝
w₂ : f₂✝ ≫ g₂✝ = 0
A₃✝ B₃✝ C₃✝ : V✝
f₃✝ : A₃✝ ⟶ B₃✝
inst✝⁹ : HasImage f₃✝
g₃✝ : B₃✝ ⟶ C₃✝
inst✝⁸ : HasKernel g₃✝
w₃ : f₃✝ ≫ g₃✝ = 0
α₁✝ : Arrow.mk f₁✝ ⟶ Arrow.mk f₂✝
inst✝⁷ : HasImageMap α₁✝
β₁✝ : Arrow.mk g₁✝ ⟶ Arrow.mk g₂✝
α₂✝ : Arrow.mk f₂✝ ⟶ Arrow.mk f₃✝
inst✝⁶ : HasImageMap α₂✝
β₂✝ : Arrow.mk g₂✝ ⟶ Arrow.mk g₃✝
inst✝⁵ : HasCokernel (imageToKernel f g w)
inst✝⁴ : HasCokernel (imageToKernel f' g' w')
inst✝³ : HasCokernel (imageToKernel f₁✝ g₁✝ w₁)
inst✝² : HasCokernel (imageToKernel f₂✝ g₂✝ w₂)
inst✝¹ : HasCokernel (imageToKernel f₃✝ g₃✝ w₃)
V : Type u_1
inst✝ : Category V
A₁ B₁ C₁ A₂ B₂ C₂ A₃ B₃ C₃ : V
f₁ : A₁ ⟶ B₁
g₁ : B₁ ⟶ C₁
f₂ : A₂ ⟶ B₂
g₂ : B₂ ⟶ C₂
f₃ : A₃ ⟶ B₃
g₃ : B₃ ⟶ C₃
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
p₁ : α₁.right = β₁.left
p₂ : α₂.right = β₂.left
⊢ (α₁ ≫ α₂).right = (β₁ ≫ β₂).left
Theorem: EMetric.infEdist_image
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp only [infEdist, iInf_image, hΦ.edist_eq]
state_before: ι : Sort ?u.19787
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
hΦ : Isometry Φ
⊢ infEdist (Φ x) (Φ '' t) = infEdist x t
Theorem: IsLocalization.mk'_zero
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [eq_comm, IsLocalization.eq_mk'_iff_mul_eq, zero_mul, map_zero]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.702381
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
s : { x // x ∈ M }
⊢ mk' S 0 s = 0
Theorem: tendsto_norm_div_self
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using
  tendsto_id.dist (tendsto_const_nhds : Tendsto (fun _a => (x : E)) (𝓝 x) _)
state_before: 𝓕 : Type ?u.454837
𝕜 : Type ?u.454840
α : Type ?u.454843
ι : Type ?u.454846
κ : Type ?u.454849
E : Type u_1
F : Type ?u.454855
G : Type ?u.454858
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x : E
⊢ Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0)
Theorem: Array.getD_eq_get?
File: Std/Data/Array/Lemmas.lean

tactic: simp [get?, getD]
state_before: α : Type u_1
a : Array α
n : Nat
d : α
⊢ getD a n d = Option.getD (get? a n) d

tactic: split <;> simp
state_before: α : Type u_1
a : Array α
n : Nat
d : α
⊢ (if h : n < size a then a[n] else d) = Option.getD (if h : n < size a then some a[n] else none) d
Theorem: CategoryTheory.Limits.kernelSubobject_comp_le
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
X Y Z✝ : C
inst✝³ : HasZeroMorphisms C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ : HasKernel f
Z : C
h : Y ⟶ Z
inst✝ : HasKernel (f ≫ h)
⊢ arrow (kernelSubobject f) ≫ f ≫ h = 0
Theorem: CategoryTheory.Limits.Types.jointly_surjective'
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: exact jointly_surjective.{v, u} F (colimit.isColimit F) x
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x : colimit F
⊢ ∃ j y, colimit.ι F j y = x
Theorem: Complex.sin_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← not_exists, not_iff_not, sin_eq_zero_iff]
state_before: θ : ℂ
⊢ sin θ ≠ 0 ↔ ∀ (k : ℤ), θ ≠ ↑k * ↑π
Theorem: neg_eq
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [add_zero]
state_before: α : Type u_1
β : Type ?u.2661
γ : Type ?u.2664
inst✝ : BooleanRing α
a b : α
⊢ -a = -a + 0

tactic: rw [← neg_add_self, add_assoc]
state_before: α : Type u_1
β : Type ?u.2661
γ : Type ?u.2664
inst✝ : BooleanRing α
a b : α
⊢ -a + 0 = -a + -a + a

tactic: rw [add_self, zero_add]
state_before: α : Type u_1
β : Type ?u.2661
γ : Type ?u.2664
inst✝ : BooleanRing α
a b : α
⊢ -a + -a + a = a
Theorem: Metric.closedBall_infDist_compl_subset_closure
File: Mathlib/Analysis/NormedSpace/RieszLemma.lean

tactic: cases' eq_or_ne (infDist x (sᶜ)) 0 with h₀ h₀
state_before: 𝕜 : Type ?u.62428
inst✝⁴ : NormedField 𝕜
E : Type ?u.62434
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
s : Set F
hx : x ∈ s
⊢ closedBall x (infDist x (sᶜ)) ⊆ closure s

tactic: rw [h₀, closedBall_zero']
state_before: case inl
𝕜 : Type ?u.62428
inst✝⁴ : NormedField 𝕜
E : Type ?u.62434
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
s : Set F
hx : x ∈ s
h₀ : infDist x (sᶜ) = 0
⊢ closedBall x (infDist x (sᶜ)) ⊆ closure s

tactic: exact closure_mono (singleton_subset_iff.2 hx)
state_before: case inl
𝕜 : Type ?u.62428
inst✝⁴ : NormedField 𝕜
E : Type ?u.62434
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
s : Set F
hx : x ∈ s
h₀ : infDist x (sᶜ) = 0
⊢ closure {x} ⊆ closure s

tactic: rw [← closure_ball x h₀]
state_before: case inr
𝕜 : Type ?u.62428
inst✝⁴ : NormedField 𝕜
E : Type ?u.62434
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
s : Set F
hx : x ∈ s
h₀ : infDist x (sᶜ) ≠ 0
⊢ closedBall x (infDist x (sᶜ)) ⊆ closure s

tactic: exact closure_mono ball_infDist_compl_subset
state_before: case inr
𝕜 : Type ?u.62428
inst✝⁴ : NormedField 𝕜
E : Type ?u.62434
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
s : Set F
hx : x ∈ s
h₀ : infDist x (sᶜ) ≠ 0
⊢ closure (ball x (infDist x (sᶜ))) ⊆ closure s
Theorem: Multiset.rel_map_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← rel_flip, rel_map_left, ← rel_flip]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.465503
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset γ
f : γ → β
⊢ Rel r s (map f t) ↔ Rel (fun a b => r a (f b)) s t

tactic: rfl
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.465503
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset γ
f : γ → β
⊢ Rel (flip fun a b => flip r (f a) b) s t ↔ Rel (fun a b => r a (f b)) s t