tasksource/leandojo huggingface dataset:
Theorem: Rat.normalize_eq_iff
File: Std/Data/Rat/Lemmas.lean

tactic: constructor <;> intro h
state_before: d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ normalize n₁ d₁ = normalize n₂ d₂ ↔ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: simp only [normalize_eq, mk'.injEq] at h
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h : normalize n₁ d₁ = normalize n₂ d₂
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: have' hn₁ := Int.ofNat_dvd_left.2 <| Nat.gcd_dvd_left n₁.natAbs d₁
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h :
  n₁ / ↑(Nat.gcd (Int.natAbs n₁) d₁) = n₂ / ↑(Nat.gcd (Int.natAbs n₂) d₂) ∧
    d₁ / Nat.gcd (Int.natAbs n₁) d₁ = d₂ / Nat.gcd (Int.natAbs n₂) d₂
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: have' hn₂ := Int.ofNat_dvd_left.2 <| Nat.gcd_dvd_left n₂.natAbs d₂
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h :
  n₁ / ↑(Nat.gcd (Int.natAbs n₁) d₁) = n₂ / ↑(Nat.gcd (Int.natAbs n₂) d₂) ∧
    d₁ / Nat.gcd (Int.natAbs n₁) d₁ = d₂ / Nat.gcd (Int.natAbs n₂) d₂
hn₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ n₁
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: have' hd₁ := Int.ofNat_dvd.2 <| Nat.gcd_dvd_right n₁.natAbs d₁
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h :
  n₁ / ↑(Nat.gcd (Int.natAbs n₁) d₁) = n₂ / ↑(Nat.gcd (Int.natAbs n₂) d₂) ∧
    d₁ / Nat.gcd (Int.natAbs n₁) d₁ = d₂ / Nat.gcd (Int.natAbs n₂) d₂
hn₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ n₁
hn₂ : ↑(Nat.gcd (Int.natAbs n₂) d₂) ∣ n₂
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: have' hd₂ := Int.ofNat_dvd.2 <| Nat.gcd_dvd_right n₂.natAbs d₂
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h :
  n₁ / ↑(Nat.gcd (Int.natAbs n₁) d₁) = n₂ / ↑(Nat.gcd (Int.natAbs n₂) d₂) ∧
    d₁ / Nat.gcd (Int.natAbs n₁) d₁ = d₂ / Nat.gcd (Int.natAbs n₂) d₂
hn₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ n₁
hn₂ : ↑(Nat.gcd (Int.natAbs n₂) d₂) ∣ n₂
hd₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ ↑d₁
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: rw [← Int.ediv_mul_cancel (Int.dvd_trans hd₂ (Int.dvd_mul_left ..)),
  Int.mul_ediv_assoc _ hd₂, ← Int.ofNat_ediv, ← h.2, Int.ofNat_ediv,
  ← Int.mul_ediv_assoc _ hd₁, Int.mul_ediv_assoc' _ hn₁,
  Int.mul_right_comm, h.1, Int.ediv_mul_cancel hn₂]
state_before: case mp
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h :
  n₁ / ↑(Nat.gcd (Int.natAbs n₁) d₁) = n₂ / ↑(Nat.gcd (Int.natAbs n₂) d₂) ∧
    d₁ / Nat.gcd (Int.natAbs n₁) d₁ = d₂ / Nat.gcd (Int.natAbs n₂) d₂
hn₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ n₁
hn₂ : ↑(Nat.gcd (Int.natAbs n₂) d₂) ∣ n₂
hd₁ : ↑(Nat.gcd (Int.natAbs n₁) d₁) ∣ ↑d₁
hd₂ : ↑(Nat.gcd (Int.natAbs n₂) d₂) ∣ ↑d₂
⊢ n₁ * ↑d₂ = n₂ * ↑d₁

tactic: rw [← normalize_mul_right _ z₂, ← normalize_mul_left z₂ z₁, Int.mul_comm d₁, h]
state_before: case mpr
d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
h : n₁ * ↑d₂ = n₂ * ↑d₁
⊢ normalize n₁ d₁ = normalize n₂ d₂
Theorem: ZMod.addOrderOf_coe'
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Nat.smul_one_eq_coe, addOrderOf_nsmul' _ a0, ZMod.addOrderOf_one]
state_before: a n : ℕ
a0 : a ≠ 0
⊢ addOrderOf ↑a = n / Nat.gcd n a
Theorem: Set.preimage_neg_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iio, ← Ioi_inter_Iic, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Ico a b = Ioc (-b) (-a)
Theorem: Equiv.Perm.isCycleOn_inv
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp only [IsCycleOn, sameCycle_inv, and_congr_left_iff]
state_before: ι : Type ?u.1642783
α : Type u_1
β : Type ?u.1642789
f g : Perm α
s t : Set α
a b x y : α
⊢ IsCycleOn f⁻¹ s ↔ IsCycleOn f s

tactic: exact fun _ ↦ ⟨fun h ↦ Set.BijOn.perm_inv h, fun h ↦ Set.BijOn.perm_inv h⟩
state_before: ι : Type ?u.1642783
α : Type u_1
β : Type ?u.1642789
f g : Perm α
s t : Set α
a b x y : α
⊢ (∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → SameCycle f x y) → (Set.BijOn (↑f⁻¹) s s ↔ Set.BijOn (↑f) s s)
Theorem: List.mem_of_elem_eq_true
File: src/lean/Init/Data/List/Basic.lean

tactic: match as with
| [] => simp [elem]
| a'::as =>
  simp [elem]
  split
  next h => intros; simp [BEq.beq] at h; subst h; apply Mem.head
  next _ => intro h; exact Mem.tail _ (mem_of_elem_eq_true h)
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as : List α
⊢ elem a as = true → a ∈ as

tactic: simp [elem]
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as : List α
⊢ elem a nil = true → a ∈ nil

tactic: simp [elem]
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
⊢ elem a (a' :: as) = true → a ∈ a' :: as

tactic: split
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
⊢ (match a == a' with
      | true => true
      | false => elem a as) =
      true →
    a ∈ a' :: as

tactic: next h => intros; simp [BEq.beq] at h; subst h; apply Mem.head
state_before: case h_1
α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
heq✝ : (a == a') = true
⊢ true = true → a ∈ a' :: as

case h_2
α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
heq✝ : (a == a') = false
⊢ elem a as = true → a ∈ a' :: as

tactic: next _ => intro h; exact Mem.tail _ (mem_of_elem_eq_true h)
state_before: case h_2
α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
heq✝ : (a == a') = false
⊢ elem a as = true → a ∈ a' :: as

tactic: intros
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
h : (a == a') = true
⊢ true = true → a ∈ a' :: as

tactic: simp [BEq.beq] at h
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
h : (a == a') = true
a✝ : true = true
⊢ a ∈ a' :: as

tactic: subst h
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
a✝ : true = true
h : a = a'
⊢ a ∈ a' :: as

tactic: apply Mem.head
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ as : List α
x✝ : Bool
a✝ : true = true
⊢ a ∈ a :: as

tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
heq✝ : (a == a') = false
⊢ elem a as = true → a ∈ a' :: as

tactic: exact Mem.tail _ (mem_of_elem_eq_true h)
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : DecidableEq α
a : α
as✝ : List α
a' : α
as : List α
x✝ : Bool
heq✝ : (a == a') = false
h : elem a as = true
⊢ a ∈ a' :: as
Theorem: Equiv.Perm.cycleFactorsFinset_injective
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: intro f g h
state_before: ι : Type ?u.2756283
α : Type u_1
β : Type ?u.2756289
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
⊢ Injective cycleFactorsFinset

tactic: rw [← cycleFactorsFinset_noncommProd f]
state_before: ι : Type ?u.2756283
α : Type u_1
β : Type ?u.2756289
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : cycleFactorsFinset f = cycleFactorsFinset g
⊢ f = g

tactic: simpa [h] using cycleFactorsFinset_noncommProd g
state_before: ι : Type ?u.2756283
α : Type u_1
β : Type ?u.2756289
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : cycleFactorsFinset f = cycleFactorsFinset g
⊢ noncommProd (cycleFactorsFinset f) id (_ : Set.Pairwise (↑(cycleFactorsFinset f)) _root_.Commute) = g
Theorem: Mathlib.Tactic.Ring.add_pf_add_zero
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ a + 0 = a
Theorem: Subgroup.map_inf_eq
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [← SetLike.coe_set_eq]
state_before: G : Type u_1
G' : Type ?u.278868
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.278877
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_2
inst✝¹ : Group N
P : Type ?u.278904
inst✝ : Group P
H K : Subgroup G
f : G →* N
hf : Injective ↑f
⊢ map f (H ⊓ K) = map f H ⊓ map f K

tactic: simp [Set.image_inter hf]
state_before: G : Type u_1
G' : Type ?u.278868
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.278877
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_2
inst✝¹ : Group N
P : Type ?u.278904
inst✝ : Group P
H K : Subgroup G
f : G →* N
hf : Injective ↑f
⊢ ↑(map f (H ⊓ K)) = ↑(map f H ⊓ map f K)
Theorem: ContractingWith.edist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
  mul_comm, ENNReal.sub_mul fun _ _ ↦ h, one_mul, tsub_le_iff_right]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
this : edist x y ≤ edist x (f x) + edist y (f y) + ↑K * edist x y
⊢ edist x y ≤ (edist x (f x) + edist y (f y)) / (1 - ↑K)

tactic: rw [edist_comm y, add_right_comm]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
⊢ edist x (f x) + edist (f x) (f y) + edist (f y) y = edist x (f x) + edist y (f y) + edist (f x) (f y)
Theorem: spectrum.one_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [Algebra.algebraMap_eq_smul_one, one_smul]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ σ 1 = σ (↑↑ₐ 1)
Theorem: MvPolynomial.eval₂_rename_prod_mk
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: intros
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type ?u.631040
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p✝ : MvPolynomial σ R
g : σ × τ → S
i : σ
p : MvPolynomial τ R
⊢ ∀ (p : MvPolynomial τ R) (n : τ),
    eval₂ f g (↑(rename (Prod.mk i)) p) = eval₂ f (fun j => g (i, j)) p →
      eval₂ f g (↑(rename (Prod.mk i)) (p * X n)) = eval₂ f (fun j => g (i, j)) (p * X n)

tactic: simp [*]
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type ?u.631040
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p✝¹ : MvPolynomial σ R
g : σ × τ → S
i : σ
p p✝ : MvPolynomial τ R
n✝ : τ
a✝ : eval₂ f g (↑(rename (Prod.mk i)) p✝) = eval₂ f (fun j => g (i, j)) p✝
⊢ eval₂ f g (↑(rename (Prod.mk i)) (p✝ * X n✝)) = eval₂ f (fun j => g (i, j)) (p✝ * X n✝)
Theorem: MonotoneOn.ae_differentiableWithinAt_of_mem
File: Mathlib/Analysis/Calculus/Monotone.lean

tactic: apply ae_of_mem_of_ae_of_mem_inter_Ioo
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
⊢ ∀ᵐ (x : ℝ), x ∈ s → DifferentiableWithinAt ℝ f s x

tactic: intro a b as bs _
state_before: case h
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
⊢ ∀ (a b : ℝ), a ∈ s → b ∈ s → a < b → ∀ᵐ (x : ℝ), x ∈ s ∩ Ioo a b → DifferentiableWithinAt ℝ f s x

tactic: obtain ⟨g, hg, gf⟩ : ∃ g : ℝ → ℝ, Monotone g ∧ EqOn f g (s ∩ Icc a b) :=
  (hf.mono (inter_subset_left s (Icc a b))).exists_monotone_extension
    (hf.map_bddBelow (inter_subset_left _ _) ⟨a, fun x hx => hx.2.1, as⟩)
    (hf.map_bddAbove (inter_subset_left _ _) ⟨b, fun x hx => hx.2.2, bs⟩)
state_before: case h
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
⊢ ∀ᵐ (x : ℝ), x ∈ s ∩ Ioo a b → DifferentiableWithinAt ℝ f s x

tactic: filter_upwards [hg.ae_differentiableAt] with x hx
state_before: case h.intro.intro
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
⊢ ∀ᵐ (x : ℝ), x ∈ s ∩ Ioo a b → DifferentiableWithinAt ℝ f s x

tactic: intro h'x
state_before: case h
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
x : ℝ
hx : DifferentiableAt ℝ g x
⊢ x ∈ s ∩ Ioo a b → DifferentiableWithinAt ℝ f s x

tactic: apply hx.differentiableWithinAt.congr_of_eventuallyEq _ (gf ⟨h'x.1, h'x.2.1.le, h'x.2.2.le⟩)
state_before: case h
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
x : ℝ
hx : DifferentiableAt ℝ g x
h'x : x ∈ s ∩ Ioo a b
⊢ DifferentiableWithinAt ℝ f s x

tactic: have : Ioo a b ∈ 𝓝[s] x := nhdsWithin_le_nhds (Ioo_mem_nhds h'x.2.1 h'x.2.2)
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
x : ℝ
hx : DifferentiableAt ℝ g x
h'x : x ∈ s ∩ Ioo a b
⊢ f =ᶠ[𝓝[s] x] g

tactic: filter_upwards [self_mem_nhdsWithin, this] with y hy h'y
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
x : ℝ
hx : DifferentiableAt ℝ g x
h'x : x ∈ s ∩ Ioo a b
this : Ioo a b ∈ 𝓝[s] x
⊢ f =ᶠ[𝓝[s] x] g

tactic: exact gf ⟨hy, h'y.1.le, h'y.2.le⟩
state_before: case h
f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
a b : ℝ
as : a ∈ s
bs : b ∈ s
a✝ : a < b
g : ℝ → ℝ
hg : Monotone g
gf : EqOn f g (s ∩ Icc a b)
x : ℝ
hx : DifferentiableAt ℝ g x
h'x : x ∈ s ∩ Ioo a b
this : Ioo a b ∈ 𝓝[s] x
y : ℝ
hy : y ∈ s
h'y : y ∈ Ioo a b
⊢ f y = g y
Theorem: MeasureTheory.setToFun_measure_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: have : f =ᵐ[μ] 0 := by simp [h, EventuallyEq]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1489190
G : Type ?u.1489193
𝕜 : Type ?u.1489196
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
h : μ = 0
⊢ setToFun μ T hT f = 0

tactic: rw [setToFun_congr_ae hT this, setToFun_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1489190
G : Type ?u.1489193
𝕜 : Type ?u.1489196
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
h : μ = 0
this : f =ᵐ[μ] 0
⊢ setToFun μ T hT f = 0

tactic: simp [h, EventuallyEq]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1489190
G : Type ?u.1489193
𝕜 : Type ?u.1489196
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
h : μ = 0
⊢ f =ᵐ[μ] 0
Theorem: Complex.AbsTheory.abs_add
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [mul_self_abs, add_mul_self_eq, mul_self_abs, mul_self_abs, add_right_comm, normSq_add,
  add_le_add_iff_left, mul_assoc, mul_le_mul_left (zero_lt_two' ℝ), ←
  Real.sqrt_mul <| normSq_nonneg z, ← normSq_conj w, ← map_mul]
state_before: z w : ℂ
⊢ Real.sqrt (↑normSq (z + w)) * Real.sqrt (↑normSq (z + w)) ≤
    (Real.sqrt (↑normSq z) + Real.sqrt (↑normSq w)) * (Real.sqrt (↑normSq z) + Real.sqrt (↑normSq w))

tactic: exact re_le_abs (z * conj w)
state_before: z w : ℂ
⊢ (z * ↑(starRingEnd ℂ) w).re ≤ Real.sqrt (↑normSq (z * ↑(starRingEnd ℂ) w))
Theorem: Pell.isPell_iff_mem_unitary
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [unitary.mem_iff, isPell_norm, mul_comm (star _), and_self_iff]
state_before: d x y : ℤ
⊢ IsPell { re := x, im := y } ↔ { re := x, im := y } ∈ unitary (ℤ√d)
Theorem: PFunctor.M.dest_mk
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: rfl
state_before: F : PFunctor
X : Type ?u.14808
f : X → Obj F X
x : Obj F (M F)
⊢ dest (M.mk x) = x
Theorem: Set.einfsep_pos_of_finite
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: cases nonempty_fintype s
state_before: α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
⊢ 0 < einfsep s

tactic: by_cases hs : s.Nontrivial
state_before: case intro
α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
val✝ : Fintype ↑s
⊢ 0 < einfsep s

tactic: rcases hs.einfsep_exists_of_finite with ⟨x, _hx, y, _hy, hxy, hxy'⟩
state_before: case pos
α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
val✝ : Fintype ↑s
hs : Set.Nontrivial s
⊢ 0 < einfsep s

tactic: exact hxy'.symm ▸ edist_pos.2 hxy
state_before: case pos.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x✝ y✝ z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
val✝ : Fintype ↑s
hs : Set.Nontrivial s
x : α
_hx : x ∈ s
y : α
_hy : y ∈ s
hxy : x ≠ y
hxy' : einfsep s = edist x y
⊢ 0 < einfsep s

tactic: rw [not_nontrivial_iff] at hs
state_before: case neg
α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
val✝ : Fintype ↑s
hs : ¬Set.Nontrivial s
⊢ 0 < einfsep s

tactic: exact hs.einfsep.symm ▸ WithTop.zero_lt_top
state_before: case neg
α : Type u_1
β : Type ?u.51801
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
val✝ : Fintype ↑s
hs : Set.Subsingleton s
⊢ 0 < einfsep s
Theorem: IntervalIntegrable.div_const
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [div_eq_mul_inv] using mul_const h c⁻¹
state_before: ι : Type ?u.6837341
𝕜✝ : Type ?u.6837344
E : Type ?u.6837347
F : Type ?u.6837350
A : Type ?u.6837353
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedRing A
f✝ g : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
𝕜 : Type u_1
f : ℝ → 𝕜
inst✝ : NormedField 𝕜
h : IntervalIntegrable f μ a b
c : 𝕜
⊢ IntervalIntegrable (fun x => f x / c) μ a b
Theorem: NNReal.summable_comp_injective
File: Mathlib/Topology/Instances/NNReal.lean

tactic: rw [← summable_coe] at hf ⊢
state_before: α : Type u_2
β : Type u_1
f : α → ℝ≥0
hf : Summable f
i : β → α
hi : Function.Injective i
⊢ Summable (f ∘ i)

tactic: exact hf.comp_injective hi
state_before: α : Type u_2
β : Type u_1
f : α → ℝ≥0
hf : Summable fun a => ↑(f a)
i : β → α
hi : Function.Injective i
⊢ Summable fun a => ↑((f ∘ i) a)
Theorem: Polynomial.mul_divByMonic_eq_iff_isRoot
File: Mathlib/Data/Polynomial/Div.lean

tactic: rw [← h, IsRoot.def, eval_mul, eval_sub, eval_X, eval_C, sub_self, MulZeroClass.zero_mul]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
h : (X - ↑C a) * (p /ₘ (X - ↑C a)) = p
⊢ IsRoot p a

tactic: conv_rhs =>
    rw [← modByMonic_add_div p (monic_X_sub_C a)]
    rw [modByMonic_X_sub_C_eq_C_eval, h, C_0, zero_add]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
h : eval a p = 0
⊢ (X - ↑C a) * (p /ₘ (X - ↑C a)) = p
Theorem: Finsupp.toMultiset_symm_apply
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: have : Finsupp.toMultiset.symm s x = Finsupp.toMultiset.invFun s x := rfl
state_before: α : Type u_1
β : Type ?u.8631
ι : Type ?u.8634
inst✝ : DecidableEq α
s : Multiset α
x : α
⊢ ↑(↑(AddEquiv.symm toMultiset) s) x = Multiset.count x s

tactic: simp_rw [this, toMultiset, coe_mk]
state_before: α : Type u_1
β : Type ?u.8631
ι : Type ?u.8634
inst✝ : DecidableEq α
s : Multiset α
x : α
this : ↑(↑(AddEquiv.symm toMultiset) s) x = ↑(Equiv.invFun toMultiset.toEquiv s) x
⊢ ↑(↑(AddEquiv.symm toMultiset) s) x = Multiset.count x s

tactic: congr
state_before: α : Type u_1
β : Type ?u.8631
ι : Type ?u.8634
inst✝ : DecidableEq α
s : Multiset α
x : α
this : ↑(↑(AddEquiv.symm toMultiset) s) x = ↑(Equiv.invFun toMultiset.toEquiv s) x
⊢ Multiset.count x s = Multiset.count x s
Theorem: Finset.coe_ssubset
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [Set.ssubset_def, Finset.coe_subset]
state_before: α : Type u_1
β : Type ?u.10650
γ : Type ?u.10653
s t s₁ s₂ : Finset α
⊢ ↑s₁ ⊂ ↑s₂ ↔ s₁ ⊆ s₂ ∧ ¬s₂ ⊆ s₁
Theorem: Turing.Tape.right₀_nth
File: Mathlib/Computability/TuringMachine.lean

tactic: cases n <;> simp only [Tape.nth, Tape.right₀, Int.ofNat_zero, ListBlank.nth_zero,
  ListBlank.nth_succ, ListBlank.head_cons, ListBlank.tail_cons, Nat.zero_eq]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
n : ℕ
⊢ ListBlank.nth (right₀ T) n = nth T ↑n
Theorem: NNReal.nndist_zero_eq_val'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [nndist_comm]
state_before: α : Type u
β : Type v
X : Type ?u.239698
ι : Type ?u.239701
inst✝ : PseudoMetricSpace α
z : ℝ≥0
⊢ nndist z 0 = z

tactic: exact NNReal.nndist_zero_eq_val z
state_before: α : Type u
β : Type v
X : Type ?u.239698
ι : Type ?u.239701
inst✝ : PseudoMetricSpace α
z : ℝ≥0
⊢ nndist 0 z = z
Theorem: Prod.disjoint_iff
File: Mathlib/Order/Disjoint.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
⊢ Disjoint x y ↔ Disjoint x.fst y.fst ∧ Disjoint x.snd y.snd

tactic: intro h
state_before: case mp
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
⊢ Disjoint x y → Disjoint x.fst y.fst ∧ Disjoint x.snd y.snd

tactic: refine' ⟨fun a hx hy ↦ (@h (a, ⊥) ⟨hx, _⟩ ⟨hy, _⟩).1,
  fun b hx hy ↦ (@h (⊥, b) ⟨_, hx⟩ ⟨_, hy⟩).2⟩
state_before: case mp
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
⊢ Disjoint x.fst y.fst ∧ Disjoint x.snd y.snd

tactic: all_goals exact bot_le
state_before: case mp.refine'_1
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
a : α
hx : a ≤ x.fst
hy : a ≤ y.fst
⊢ (a, ⊥).snd ≤ x.snd

case mp.refine'_2
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
a : α
hx : a ≤ x.fst
hy : a ≤ y.fst
⊢ (a, ⊥).snd ≤ y.snd

case mp.refine'_3
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
b : β
hx : b ≤ x.snd
hy : b ≤ y.snd
⊢ (⊥, b).fst ≤ x.fst

case mp.refine'_4
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
b : β
hx : b ≤ x.snd
hy : b ≤ y.snd
⊢ (⊥, b).fst ≤ y.fst

tactic: exact bot_le
state_before: case mp.refine'_4
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
h : Disjoint x y
b : β
hx : b ≤ x.snd
hy : b ≤ y.snd
⊢ (⊥, b).fst ≤ y.fst

tactic: rintro ⟨ha, hb⟩ z hza hzb
state_before: case mpr
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
⊢ Disjoint x.fst y.fst ∧ Disjoint x.snd y.snd → Disjoint x y

tactic: refine' ⟨ha hza.1 hzb.1, hb hza.2 hzb.2⟩
state_before: case mpr.intro
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
x y : α × β
ha : Disjoint x.fst y.fst
hb : Disjoint x.snd y.snd
z : α × β
hza : z ≤ x
hzb : z ≤ y
⊢ z ≤ ⊥
Theorem: Nat.cast_le_one
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: rw [← cast_one, cast_le]
state_before: α : Type u_1
β : Type ?u.20573
inst✝¹ : OrderedSemiring α
inst✝ : CharZero α
m n : ℕ
⊢ ↑n ≤ 1 ↔ n ≤ 1
Theorem: Ordinal.sub_eq_zero_iff_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [h, add_zero] using le_add_sub a b
state_before: α : Type ?u.132338
β : Type ?u.132341
γ : Type ?u.132344
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : a - b = 0
⊢ a ≤ b

tactic: rwa [← Ordinal.le_zero, sub_le, add_zero]
state_before: α : Type ?u.132338
β : Type ?u.132341
γ : Type ?u.132344
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : a ≤ b
⊢ a - b = 0