tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.vars_map
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical simp [vars_def, degrees_map]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.199688
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : R →+* S
⊢ vars (↑(map f) p) ⊆ vars p

tactic: simp [vars_def, degrees_map]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.199688
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : R →+* S
⊢ vars (↑(map f) p) ⊆ vars p
Theorem: Nat.max_eq_zero_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: constructor
state_before: m n k l : ℕ
⊢ max m n = 0 ↔ m = 0 ∧ n = 0

tactic: intro h
state_before: case mp
m n k l : ℕ
⊢ max m n = 0 → m = 0 ∧ n = 0

tactic: cases' le_total m n with H H
state_before: case mp
m n k l : ℕ
h : max m n = 0
⊢ m = 0 ∧ n = 0

tactic: simp only [H, max_eq_right] at h
state_before: case mp.inl
m n k l : ℕ
h : max m n = 0
H : m ≤ n
⊢ m = 0 ∧ n = 0

tactic: exact ⟨le_antisymm (H.trans h.le) (zero_le _), h⟩
state_before: case mp.inl
m n k l : ℕ
H : m ≤ n
h : n = 0
⊢ m = 0 ∧ n = 0

tactic: simp only [H, max_eq_left] at h
state_before: case mp.inr
m n k l : ℕ
h : max m n = 0
H : n ≤ m
⊢ m = 0 ∧ n = 0

tactic: exact ⟨h, le_antisymm (H.trans h.le) (zero_le _)⟩
state_before: case mp.inr
m n k l : ℕ
H : n ≤ m
h : m = 0
⊢ m = 0 ∧ n = 0

tactic: rintro ⟨rfl, rfl⟩
state_before: case mpr
m n k l : ℕ
⊢ m = 0 ∧ n = 0 → max m n = 0

tactic: simp
state_before: case mpr.intro
k l : ℕ
⊢ max 0 0 = 0
Theorem: isClosed_range_of_spaced_out
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rintro _ ⟨x, rfl⟩ _ ⟨y, rfl⟩ h
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
ι : Type u_1
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
f : ι → α
hf : Pairwise fun x y => ¬(f x, f y) ∈ V₀
⊢ Set.Pairwise (range f) fun x y => ¬(x, y) ∈ V₀

tactic: exact hf (ne_of_apply_ne f h)
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
ι : Type u_1
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
f : ι → α
hf : Pairwise fun x y => ¬(f x, f y) ∈ V₀
x y : ι
h : f x ≠ f y
⊢ ¬(f x, f y) ∈ V₀
Theorem: List.Nodup.insert
File: Mathlib/Data/List/Nodup.lean

tactic: rw [insert_of_mem h']
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
h : Nodup l
h' : a ∈ l
⊢ Nodup (List.insert a l)

tactic: exact h
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
h : Nodup l
h' : a ∈ l
⊢ Nodup l

tactic: rw [insert_of_not_mem h', nodup_cons]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
h : Nodup l
h' : ¬a ∈ l
⊢ Nodup (List.insert a l)

tactic: constructor <;> assumption
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
h : Nodup l
h' : ¬a ∈ l
⊢ ¬a ∈ l ∧ Nodup l
Theorem: MeasureTheory.L1.SimpleFunc.integral_eq_lintegral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral, SimpleFunc.integral_eq_lintegral (SimpleFunc.integrable f) h_pos]
state_before: α : Type u_1
E : Type ?u.240860
F : Type ?u.240863
𝕜 : Type ?u.240866
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace ℝ E
inst✝² : SMulCommClass ℝ 𝕜 E
F' : Type ?u.243241
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
f : { x // x ∈ simpleFunc ℝ 1 μ }
h_pos : 0 ≤ᵐ[μ] ↑(toSimpleFunc f)
⊢ integral f = ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal (↑(toSimpleFunc f) a) ∂μ)
Theorem: Real.rpow_le_rpow_of_exponent_ge'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases eq_or_lt_of_le hx0 with (rfl | hx0')
state_before: x y z : ℝ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z

tactic: rcases eq_or_lt_of_le hz with (rfl | hz')
state_before: case inl
y z : ℝ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
⊢ 0 ^ y ≤ 0 ^ z

tactic: rw [zero_rpow, zero_rpow] <;> linarith
state_before: case inl.inr
y z : ℝ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz' : 0 < z
⊢ 0 ^ y ≤ 0 ^ z

tactic: exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
state_before: case inl.inl
y : ℝ
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz : 0 ≤ 0
hyz : 0 ≤ y
⊢ 0 ^ y ≤ 0 ^ 0

tactic: exact rpow_le_rpow_of_exponent_ge hx0' hx1 hyz
state_before: case inr
x y z : ℝ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
hx0' : 0 < x
⊢ x ^ y ≤ x ^ z
Theorem: deriv_forall_lt_or_forall_gt_of_forall_ne
File: Mathlib/Analysis/Calculus/Darboux.lean

tactic: contrapose! hf'
state_before: a b : ℝ
f f' : ℝ → ℝ
s : Set ℝ
hs : Convex ℝ s
hf : ∀ (x : ℝ), x ∈ s → HasDerivAt f (f' x) x
m : ℝ
hf' : ∀ (x : ℝ), x ∈ s → f' x ≠ m
⊢ (∀ (x : ℝ), x ∈ s → f' x < m) ∨ ∀ (x : ℝ), x ∈ s → m < f' x

tactic: rcases hf' with ⟨⟨b, hb, hmb⟩, ⟨a, ha, hma⟩⟩
state_before: a b : ℝ
f f' : ℝ → ℝ
s : Set ℝ
hs : Convex ℝ s
hf : ∀ (x : ℝ), x ∈ s → HasDerivAt f (f' x) x
m : ℝ
hf' : (∃ x, x ∈ s ∧ m ≤ f' x) ∧ ∃ x, x ∈ s ∧ f' x ≤ m
⊢ ∃ x, x ∈ s ∧ f' x = m

tactic: exact (convex_image_hasDerivAt hs hf).ordConnected.out
  (mem_image_of_mem f' ha) (mem_image_of_mem f' hb) ⟨hma, hmb⟩
state_before: case intro.intro.intro.intro.intro
a✝ b✝ : ℝ
f f' : ℝ → ℝ
s : Set ℝ
hs : Convex ℝ s
hf : ∀ (x : ℝ), x ∈ s → HasDerivAt f (f' x) x
m b : ℝ
hb : b ∈ s
hmb : m ≤ f' b
a : ℝ
ha : a ∈ s
hma : f' a ≤ m
⊢ ∃ x, x ∈ s ∧ f' x = m
Theorem: CompositionSeries.total
File: Mathlib/Order/JordanHolder.lean

tactic: rcases Set.mem_range.1 hx with ⟨i, rfl⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
x y : X
hx : x ∈ s
hy : y ∈ s
⊢ x ≤ y ∨ y ≤ x

tactic: rcases Set.mem_range.1 hy with ⟨j, rfl⟩
state_before: case intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
y : X
hy : y ∈ s
i : Fin (s.length + 1)
hx : series s i ∈ s
⊢ series s i ≤ y ∨ y ≤ series s i

tactic: rw [s.strictMono.le_iff_le, s.strictMono.le_iff_le]
state_before: case intro.intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ∈ s
j : Fin (s.length + 1)
hy : series s j ∈ s
⊢ series s i ≤ series s j ∨ series s j ≤ series s i

tactic: exact le_total i j
state_before: case intro.intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ∈ s
j : Fin (s.length + 1)
hy : series s j ∈ s
⊢ i ≤ j ∨ j ≤ i
Theorem: Nat.min_succ_succ
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.min_def, succ_le_succ_iff]
state_before: x y : Nat
⊢ min (succ x) (succ y) = succ (min x y)

tactic: split <;> rfl
state_before: x y : Nat
⊢ (if x ≤ y then succ x else succ y) = succ (if x ≤ y then x else y)
Theorem: List.map_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp
state_before: α : Type u
β : Type u_1
n : ℕ
f : Fin n → α
g : α → β
⊢ length (map g (ofFn f)) = length (ofFn (g ∘ f))

tactic: simp
state_before: α : Type u
β : Type u_1
n : ℕ
f : Fin n → α
g : α → β
i : ℕ
h : i < length (map g (ofFn f))
h' : i < length (ofFn (g ∘ f))
⊢ get (map g (ofFn f)) { val := i, isLt := h } = get (ofFn (g ∘ f)) { val := i, isLt := h' }
Theorem: UniqueFactorizationMonoid.of_exists_unique_irreducible_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: convert eif using 7
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
eif : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Irreducible b) ∧ Multiset.prod f ~ᵤ a
uif :
  ∀ (f g : Multiset α),
    (∀ (x : α), x ∈ f → Irreducible x) →
      (∀ (x : α), x ∈ g → Irreducible x) → Multiset.prod f ~ᵤ Multiset.prod g → Multiset.Rel Associated f g
⊢ ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a

tactic: simp_rw [irreducible_iff_prime_of_exists_unique_irreducible_factors eif uif]
state_before: case h.h'.h.e'_2.h.h.e'_1.h.h'.a
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
eif : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Irreducible b) ∧ Multiset.prod f ~ᵤ a
uif :
  ∀ (f g : Multiset α),
    (∀ (x : α), x ∈ f → Irreducible x) →
      (∀ (x : α), x ∈ g → Irreducible x) → Multiset.prod f ~ᵤ Multiset.prod g → Multiset.Rel Associated f g
a✝³ : α
a✝² : a✝³ ≠ 0
x✝ : Multiset α
a✝¹ : α
a✝ : a✝¹ ∈ x✝
⊢ Prime a✝¹ ↔ Irreducible a✝¹
Theorem: Prod.tendsto_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_prod_eq, Filter.tendsto_prod_iff']
state_before: α✝ : Type u
β : Type v
γ : Type u_2
δ : Type ?u.37506
ε : Type ?u.37509
ζ : Type ?u.37512
inst✝⁵ : TopologicalSpace α✝
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
α : Type u_1
seq : α → β × γ
f : Filter α
x : β × γ
⊢ Tendsto seq f (𝓝 x) ↔ Tendsto (fun n => (seq n).fst) f (𝓝 x.fst) ∧ Tendsto (fun n => (seq n).snd) f (𝓝 x.snd)
Theorem: Int.gcd_ne_one_iff_gcd_mul_right_ne_one
File: Mathlib/RingTheory/Int/Basic.lean

tactic: simp only [gcd_eq_one_iff_coprime, ← not_and_or, not_iff_not, IsCoprime.mul_right_iff]
state_before: a : ℤ
m n : ℕ
⊢ gcd a (↑m * ↑n) ≠ 1 ↔ gcd a ↑m ≠ 1 ∨ gcd a ↑n ≠ 1
Theorem: ContinuousLinearMap.inCoordinates_eq
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: ext
state_before: R : Type ?u.523106
B : Type u_5
F : Type u_6
E : B → Type u_3
inst✝²² : NontriviallyNormedField R
inst✝²¹ : (x : B) → AddCommMonoid (E x)
inst✝²⁰ : (x : B) → Module R (E x)
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace R F
inst✝¹⁷ : TopologicalSpace B
inst✝¹⁶ : (x : B) → TopologicalSpace (E x)
𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝¹⁵ : NontriviallyNormedField 𝕜₁
inst✝¹⁴ : NontriviallyNormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
B' : Type u_7
inst✝¹³ : TopologicalSpace B'
inst✝¹² : NormedSpace 𝕜₁ F
inst✝¹¹ : (x : B) → Module 𝕜₁ (E x)
inst✝¹⁰ : TopologicalSpace (TotalSpace E)
F' : Type u_8
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜₂ F'
E' : B' → Type u_4
inst✝⁷ : (x : B') → AddCommMonoid (E' x)
inst✝⁶ : (x : B') → Module 𝕜₂ (E' x)
inst✝⁵ : TopologicalSpace (TotalSpace E')
inst✝⁴ : FiberBundle F E
inst✝³ : VectorBundle 𝕜₁ F E
inst✝² : (x : B') → TopologicalSpace (E' x)
inst✝¹ : FiberBundle F' E'
inst✝ : VectorBundle 𝕜₂ F' E'
x₀ x : B
y₀ y : B'
ϕ : E x →SL[σ] E' y
hx : x ∈ (trivializationAt F E x₀).baseSet
hy : y ∈ (trivializationAt F' E' y₀).baseSet
⊢ inCoordinates F E F' E' x₀ x y₀ y ϕ =
    comp (↑(Trivialization.continuousLinearEquivAt 𝕜₂ (trivializationAt F' E' y₀) y hy))
      (comp ϕ ↑(ContinuousLinearEquiv.symm (Trivialization.continuousLinearEquivAt 𝕜₁ (trivializationAt F E x₀) x hx)))

tactic: simp_rw [inCoordinates, ContinuousLinearMap.coe_comp', ContinuousLinearEquiv.coe_coe,
  Trivialization.coe_continuousLinearEquivAt_eq, Trivialization.symm_continuousLinearEquivAt_eq]
state_before: case h
R : Type ?u.523106
B : Type u_5
F : Type u_6
E : B → Type u_3
inst✝²² : NontriviallyNormedField R
inst✝²¹ : (x : B) → AddCommMonoid (E x)
inst✝²⁰ : (x : B) → Module R (E x)
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace R F
inst✝¹⁷ : TopologicalSpace B
inst✝¹⁶ : (x : B) → TopologicalSpace (E x)
𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝¹⁵ : NontriviallyNormedField 𝕜₁
inst✝¹⁴ : NontriviallyNormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
B' : Type u_7
inst✝¹³ : TopologicalSpace B'
inst✝¹² : NormedSpace 𝕜₁ F
inst✝¹¹ : (x : B) → Module 𝕜₁ (E x)
inst✝¹⁰ : TopologicalSpace (TotalSpace E)
F' : Type u_8
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜₂ F'
E' : B' → Type u_4
inst✝⁷ : (x : B') → AddCommMonoid (E' x)
inst✝⁶ : (x : B') → Module 𝕜₂ (E' x)
inst✝⁵ : TopologicalSpace (TotalSpace E')
inst✝⁴ : FiberBundle F E
inst✝³ : VectorBundle 𝕜₁ F E
inst✝² : (x : B') → TopologicalSpace (E' x)
inst✝¹ : FiberBundle F' E'
inst✝ : VectorBundle 𝕜₂ F' E'
x₀ x : B
y₀ y : B'
ϕ : E x →SL[σ] E' y
hx : x ∈ (trivializationAt F E x₀).baseSet
hy : y ∈ (trivializationAt F' E' y₀).baseSet
x✝ : F
⊢ ↑(inCoordinates F E F' E' x₀ x y₀ y ϕ) x✝ =
    ↑(comp (↑(Trivialization.continuousLinearEquivAt 𝕜₂ (trivializationAt F' E' y₀) y hy))
          (comp ϕ
            ↑(ContinuousLinearEquiv.symm (Trivialization.continuousLinearEquivAt 𝕜₁ (trivializationAt F E x₀) x hx))))
      x✝
Theorem: Pell.yz_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [sub_eq_add_neg, ← mul_neg, mul_comm, add_comm]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ yz a1 (m - n) = xz a1 n * yz a1 m - xz a1 m * yz a1 n

tactic: exact congr_arg Zsqrtd.im (pellZd_sub a1 h)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ yz a1 (m - n) = xz a1 m * -yz a1 n + yz a1 m * xz a1 n
Theorem: thickenedIndicator_one_of_mem_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_toNNReal]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
x_mem : x ∈ closure E
⊢ ↑(thickenedIndicator δ_pos E) x = 1
Theorem: MvQPF.Fix.rec_unique
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: ext x
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
h : Fix F α → β
hyp : ∀ (x : F (α ::: Fix F α)), h (mk x) = g ((TypeVec.id ::: h) <$$> x)
⊢ rec g = h

tactic: apply Fix.ind_rec
state_before: case h
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
h : Fix F α → β
hyp : ∀ (x : F (α ::: Fix F α)), h (mk x) = g ((TypeVec.id ::: h) <$$> x)
x : Fix F α
⊢ rec g x = h x

tactic: intro x hyp'
state_before: case h.h
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
h : Fix F α → β
hyp : ∀ (x : F (α ::: Fix F α)), h (mk x) = g ((TypeVec.id ::: h) <$$> x)
x : Fix F α
⊢ ∀ (x : F (α ::: Fix F α)),
    (TypeVec.id ::: rec g) <$$> x = (TypeVec.id ::: fun x => h x) <$$> x → rec g (mk x) = h (mk x)

tactic: rw [hyp, ← hyp', Fix.rec_eq]
state_before: case h.h
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
h : Fix F α → β
hyp : ∀ (x : F (α ::: Fix F α)), h (mk x) = g ((TypeVec.id ::: h) <$$> x)
x✝ : Fix F α
x : F (α ::: Fix F α)
hyp' : (TypeVec.id ::: rec g) <$$> x = (TypeVec.id ::: fun x => h x) <$$> x
⊢ rec g (mk x) = h (mk x)
Theorem: Finsupp.erase_of_not_mem_support
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext b
state_before: α : Type u_1
β : Type ?u.166602
γ : Type ?u.166605
ι : Type ?u.166608
M : Type u_2
M' : Type ?u.166614
N : Type ?u.166617
P : Type ?u.166620
G : Type ?u.166623
H : Type ?u.166626
R : Type ?u.166629
S : Type ?u.166632
inst✝ : Zero M
f : α →₀ M
a : α
haf : ¬a ∈ f.support
⊢ erase a f = f

tactic: by_cases hab : b = a
state_before: case h
α : Type u_1
β : Type ?u.166602
γ : Type ?u.166605
ι : Type ?u.166608
M : Type u_2
M' : Type ?u.166614
N : Type ?u.166617
P : Type ?u.166620
G : Type ?u.166623
H : Type ?u.166626
R : Type ?u.166629
S : Type ?u.166632
inst✝ : Zero M
f : α →₀ M
a : α
haf : ¬a ∈ f.support
b : α
⊢ ↑(erase a f) b = ↑f b

tactic: rwa [hab, erase_same, eq_comm, ← not_mem_support_iff]
state_before: case pos
α : Type u_1
β : Type ?u.166602
γ : Type ?u.166605
ι : Type ?u.166608
M : Type u_2
M' : Type ?u.166614
N : Type ?u.166617
P : Type ?u.166620
G : Type ?u.166623
H : Type ?u.166626
R : Type ?u.166629
S : Type ?u.166632
inst✝ : Zero M
f : α →₀ M
a : α
haf : ¬a ∈ f.support
b : α
hab : b = a
⊢ ↑(erase a f) b = ↑f b

tactic: rw [erase_ne hab]
state_before: case neg
α : Type u_1
β : Type ?u.166602
γ : Type ?u.166605
ι : Type ?u.166608
M : Type u_2
M' : Type ?u.166614
N : Type ?u.166617
P : Type ?u.166620
G : Type ?u.166623
H : Type ?u.166626
R : Type ?u.166629
S : Type ?u.166632
inst✝ : Zero M
f : α →₀ M
a : α
haf : ¬a ∈ f.support
b : α
hab : ¬b = a
⊢ ↑(erase a f) b = ↑f b
Theorem: MeasureTheory.SimpleFunc.finset_sup_apply
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: refine' Finset.induction_on s rfl _
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.804933
inst✝² : MeasurableSpace α
K : Type ?u.804939
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s : Finset γ
a : α
⊢ ↑(Finset.sup s f) a = Finset.sup s fun c => ↑(f c) a

tactic: intro a s _ ih
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.804933
inst✝² : MeasurableSpace α
K : Type ?u.804939
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s : Finset γ
a : α
⊢ ∀ ⦃a_1 : γ⦄ {s : Finset γ},
    ¬a_1 ∈ s →
      (↑(Finset.sup s f) a = Finset.sup s fun c => ↑(f c) a) →
        ↑(Finset.sup (insert a_1 s) f) a = Finset.sup (insert a_1 s) fun c => ↑(f c) a

tactic: rw [Finset.sup_insert, Finset.sup_insert, sup_apply, ih]
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.804933
inst✝² : MeasurableSpace α
K : Type ?u.804939
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s✝ : Finset γ
a✝¹ : α
a : γ
s : Finset γ
a✝ : ¬a ∈ s
ih : ↑(Finset.sup s f) a✝¹ = Finset.sup s fun c => ↑(f c) a✝¹
⊢ ↑(Finset.sup (insert a s) f) a✝¹ = Finset.sup (insert a s) fun c => ↑(f c) a✝¹
Theorem: MeasureTheory.Measure.dirac_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.327267
γ : Type ?u.327270
δ : Type ?u.327273
ι : Type ?u.327276
R : Type ?u.327279
R' : Type ?u.327282
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
⊢ ↑↑(dirac a) s = indicator s 1 a

tactic: rw [indicator_of_not_mem h, ← nonpos_iff_eq_zero]
state_before: case neg
α : Type u_1
β : Type ?u.327267
γ : Type ?u.327270
δ : Type ?u.327273
ι : Type ?u.327276
R : Type ?u.327279
R' : Type ?u.327282
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : ¬a ∈ s
⊢ ↑↑(dirac a) s = indicator s 1 a

tactic: calc
  dirac a s ≤ dirac a ({a}ᶜ) := measure_mono (subset_compl_comm.1 <| singleton_subset_iff.2 h)
  _ = 0 := by simp [dirac_apply' _ (measurableSet_singleton _).compl]
state_before: case neg
α : Type u_1
β : Type ?u.327267
γ : Type ?u.327270
δ : Type ?u.327273
ι : Type ?u.327276
R : Type ?u.327279
R' : Type ?u.327282
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : ¬a ∈ s
⊢ ↑↑(dirac a) s ≤ 0

tactic: rw [dirac_apply_of_mem h, indicator_of_mem h, Pi.one_apply]
state_before: case pos
α : Type u_1
β : Type ?u.327267
γ : Type ?u.327270
δ : Type ?u.327273
ι : Type ?u.327276
R : Type ?u.327279
R' : Type ?u.327282
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∈ s
⊢ ↑↑(dirac a) s = indicator s 1 a

tactic: simp [dirac_apply' _ (measurableSet_singleton _).compl]
state_before: α : Type u_1
β : Type ?u.327267
γ : Type ?u.327270
δ : Type ?u.327273
ι : Type ?u.327276
R : Type ?u.327279
R' : Type ?u.327282
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : ¬a ∈ s
⊢ ↑↑(dirac a) ({a}ᶜ) = 0
Theorem: interior_eq_empty_iff_dense_compl
File: Mathlib/Topology/Basic.lean

tactic: rw [dense_iff_closure_eq, closure_compl, compl_univ_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ interior s = ∅ ↔ Dense (sᶜ)
Theorem: Submonoid.mem_closure_singleton
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [closure_singleton_eq, mem_mrange]
state_before: M : Type u_1
A : Type ?u.55052
B : Type ?u.55055
inst✝ : Monoid M
x y : M
⊢ y ∈ closure {x} ↔ ∃ n, x ^ n = y

tactic: rfl
state_before: M : Type u_1
A : Type ?u.55052
B : Type ?u.55055
inst✝ : Monoid M
x y : M
⊢ (∃ x_1, ↑(↑(powersHom M) x) x_1 = y) ↔ ∃ n, x ^ n = y
Theorem: ProbabilityTheory.condCount_singleton
File: Mathlib/Probability/CondCount.lean

tactic: rw [condCount, cond_apply _ (measurableSet_singleton ω), Measure.count_singleton, inv_one,
  one_mul]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
⊢ ↑↑(condCount {ω}) t = if ω ∈ t then 1 else 0

tactic: split_ifs
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
⊢ ↑↑Measure.count ({ω} ∩ t) = if ω ∈ t then 1 else 0

tactic: rw [(by simpa : ({ω} : Set Ω) ∩ t = {ω}), Measure.count_singleton]
state_before: case inl
Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
h✝ : ω ∈ t
⊢ ↑↑Measure.count ({ω} ∩ t) = 1

tactic: simpa
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
h✝ : ω ∈ t
⊢ {ω} ∩ t = {ω}

tactic: rw [(by simpa : ({ω} : Set Ω) ∩ t = ∅), Measure.count_empty]
state_before: case inr
Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
h✝ : ¬ω ∈ t
⊢ ↑↑Measure.count ({ω} ∩ t) = 0

tactic: simpa
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : MeasurableSingletonClass Ω
ω : Ω
t : Set Ω
inst✝ : Decidable (ω ∈ t)
h✝ : ¬ω ∈ t
⊢ {ω} ∩ t = ∅
Theorem: Real.abs_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_sq_eq_abs]
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ abs x ≤ sqrt y

tactic: exact sqrt_le_sqrt h
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ sqrt (x ^ 2) ≤ sqrt y
Theorem: AList.insert_insert_of_ne
File: Mathlib/Data/List/AList.lean

tactic: simp only [insert_entries]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s : AList β
h : a ≠ a'
⊢ (insert a' b' (insert a b s)).entries ~ (insert a b (insert a' b' s)).entries

tactic: rw [kerase_cons_ne, kerase_cons_ne, kerase_comm] <;>
[apply Perm.swap; exact h; exact h.symm]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s : AList β
h : a ≠ a'
⊢ { fst := a', snd := b' } :: kerase a' ({ fst := a, snd := b } :: kerase a s.entries) ~
    { fst := a, snd := b } :: kerase a ({ fst := a', snd := b' } :: kerase a' s.entries)