1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Multiset.finite_toSet
File: Mathlib/Data/Set/Finite.lean

tactic: classical simpa only [← Multiset.mem_toFinset] using s.toFinset.finite_toSet
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Multiset α
⊢ {x | x ∈ s}.Finite
state_after: no goals

tactic: simpa only [← Multiset.mem_toFinset] using s.toFinset.finite_toSet
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Multiset α
⊢ {x | x ∈ s}.Finite
state_after: no goals
Theorem: Complex.exp_add_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp_add, exp_mul_I]
state_before: x y : ℂ
⊢ cexp (x + y * I) = cexp x * (cos y + sin y * I)
state_after: no goals
Theorem: ProbabilityTheory.poissonPMFRealSum
File: Mathlib/Probability/Distributions/Poisson.lean

tactic: let r := r.toReal
state_before: r : ℝ≥0
⊢ HasSum (fun n => poissonPMFReal r n) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => poissonPMFReal r✝ n) 1

tactic: unfold poissonPMFReal
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => poissonPMFReal r✝ n) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => rexp (-↑r✝) * ↑r✝ ^ n / ↑n !) 1

tactic: apply (hasSum_mul_left_iff (exp_ne_zero r)).mp
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => rexp (-↑r✝) * ↑r✝ ^ n / ↑n !) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r * 1)

tactic: simp only [mul_one]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r * 1)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)

tactic: have : (fun i ↦ rexp r * (rexp (-r) * r ^ i / ↑(Nat.factorial i))) =
    fun i ↦ r ^ i / ↑(Nat.factorial i) := by
  ext n
  rw [mul_div_assoc, exp_neg, ← mul_assoc, ← div_eq_mul_inv, div_self (exp_ne_zero r), one_mul]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)

tactic: rw [this, exp_eq_exp_ℝ]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => r ^ i / ↑i !) (NormedSpace.exp ℝ r)

tactic: exact NormedSpace.expSeries_div_hasSum_exp ℝ r
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => r ^ i / ↑i !) (NormedSpace.exp ℝ r)
state_after: no goals

tactic: ext n
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
state_after: case h
r✝ : ℝ≥0
r : ℝ := ↑r✝
n : ℕ
⊢ rexp r * (rexp (-r) * r ^ n / ↑n !) = r ^ n / ↑n !

tactic: rw [mul_div_assoc, exp_neg, ← mul_assoc, ← div_eq_mul_inv, div_self (exp_ne_zero r), one_mul]
state_before: case h
r✝ : ℝ≥0
r : ℝ := ↑r✝
n : ℕ
⊢ rexp r * (rexp (-r) * r ^ n / ↑n !) = r ^ n / ↑n !
state_after: no goals
Theorem: ENNReal.div_mul_cancel
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [div_eq_mul_inv, mul_assoc, ENNReal.inv_mul_cancel h0 hI, mul_one]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hI : a ≠ ⊤
⊢ b / a * a = b
state_after: no goals
Theorem: smul_lt_iff_lt_one_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [one_smul]
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁷ : Monoid α
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : MulAction α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : SMulPosStrictMono α β
inst✝ : SMulPosReflectLT α β
hb : 0 < b
⊢ a • b < b ↔ a • b < 1 • b
state_after: no goals
Theorem: Polynomial.aeval_algHom_apply
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

tactic: refine Polynomial.induction_on p (by simp [AlgHomClass.commutes]) (fun p q hp hq => ?_)
  (by simp [AlgHomClass.commutes])
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R A
inst✝³ : Algebra R A'
inst✝² : Algebra R B
p✝ q : R[X]
x✝ : A
F : Type u_3
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
f : F
x : A
p : R[X]
⊢ (aeval (f x)) p = f ((aeval x) p)
state_after: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R A
inst✝³ : Algebra R A'
inst✝² : Algebra R B
p✝¹ q✝ : R[X]
x✝ : A
F : Type u_3
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
f : F
x : A
p✝ p q : R[X]
hp : (aeval (f x)) p = f ((aeval x) p)
hq : (aeval (f x)) q = f ((aeval x) q)
⊢ (aeval (f x)) (p + q) = f ((aeval x) (p + q))

tactic: rw [map_add, hp, hq, ← map_add, ← map_add]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R A
inst✝³ : Algebra R A'
inst✝² : Algebra R B
p✝¹ q✝ : R[X]
x✝ : A
F : Type u_3
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
f : F
x : A
p✝ p q : R[X]
hp : (aeval (f x)) p = f ((aeval x) p)
hq : (aeval (f x)) q = f ((aeval x) q)
⊢ (aeval (f x)) (p + q) = f ((aeval x) (p + q))
state_after: no goals

tactic: simp [AlgHomClass.commutes]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R A
inst✝³ : Algebra R A'
inst✝² : Algebra R B
p✝ q : R[X]
x✝ : A
F : Type u_3
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
f : F
x : A
p : R[X]
⊢ ∀ (a : R), (aeval (f x)) (C a) = f ((aeval x) (C a))
state_after: no goals

tactic: simp [AlgHomClass.commutes]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R A
inst✝³ : Algebra R A'
inst✝² : Algebra R B
p✝ q : R[X]
x✝ : A
F : Type u_3
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
f : F
x : A
p : R[X]
⊢ ∀ (n : ℕ) (a : R),
    (aeval (f x)) (C a * X ^ n) = f ((aeval x) (C a * X ^ n)) →
      (aeval (f x)) (C a * X ^ (n + 1)) = f ((aeval x) (C a * X ^ (n + 1)))
state_after: no goals
Theorem: Matrix.neg_dotProduct_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [neg_dotProduct, dotProduct_neg, neg_neg]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ -v ⬝ᵥ -w = v ⬝ᵥ w
state_after: no goals
Theorem: Polynomial.degree_gcd_le_left
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: have := natDegree_le_iff_degree_le.mp (natDegree_le_of_dvd (gcd_dvd_left p q) hp)
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p ≠ 0
q : R[X]
⊢ (gcd p q).degree ≤ p.degree
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p ≠ 0
q : R[X]
this : (gcd p q).degree ≤ ↑p.natDegree
⊢ (gcd p q).degree ≤ p.degree

tactic: rwa [degree_eq_natDegree hp]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p ≠ 0
q : R[X]
this : (gcd p q).degree ≤ ↑p.natDegree
⊢ (gcd p q).degree ≤ p.degree
state_after: no goals
Theorem: Finset.sup_eq_bot_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: classical induction' S using Finset.induction with a S _ hi <;> simp [*]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
f : β → α
S : Finset β
⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥
state_after: no goals

tactic: induction' S using Finset.induction with a S _ hi <;> simp [*]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
f : β → α
S : Finset β
⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥
state_after: no goals
Theorem: sInf_mem_of_not_isPredLimit
File: Mathlib/Order/SuccPred/CompleteLinearOrder.lean

tactic: obtain ⟨y, hy⟩ := not_forall_not.mp hlim
state_before: ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsPredLimit (sInf s)
⊢ sInf s ∈ s
state_after: case intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s

tactic: obtain ⟨i, his, hi⟩ := sInf_lt_iff.mp hy.lt
state_before: case intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
i : α
his : i ∈ s
hi : i < y
⊢ sInf s ∈ s
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.pi
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

tactic: intro _ _ f hf
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
⊢ (MorphismProperty.pi W).IsInvertedBy (Functor.pi F)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ IsIso ((Functor.pi F).map f)

tactic: rw [isIso_pi_iff]
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ IsIso ((Functor.pi F).map f)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ ∀ (i : J), IsIso ((Functor.pi F).map f i)

tactic: intro j
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ ∀ (i : J), IsIso ((Functor.pi F).map f i)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
j : J
⊢ IsIso ((Functor.pi F).map f j)

tactic: exact hF j _ (hf j)
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
j : J
⊢ IsIso ((Functor.pi F).map f j)
state_after: no goals
Theorem: List.Nodup.concat
File: Mathlib/Data/List/Nodup.lean

tactic: rw [concat_eq_append]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
h : a ∉ l
h' : l.Nodup
⊢ (l.concat a).Nodup
state_after: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
h : a ∉ l
h' : l.Nodup
⊢ (l ++ [a]).Nodup

tactic: exact h'.append (nodup_singleton _) (disjoint_singleton.2 h)
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
h : a ∉ l
h' : l.Nodup
⊢ (l ++ [a]).Nodup
state_after: no goals
Theorem: Set.eq_of_preimage_val_eq_of_subset
File: Mathlib/Data/Set/Subset.lean

tactic: simp only [← inter_eq_right] at hB hC
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hB : B ⊆ A
hC : C ⊆ A
h : A ↓∩ B = A ↓∩ C
⊢ B = C
state_after: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
h : A ↓∩ B = A ↓∩ C
hB : A ∩ B = B
hC : A ∩ C = C
⊢ B = C

tactic: simp only [Subtype.preimage_val_eq_preimage_val_iff, hB, hC] at h
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
h : A ↓∩ B = A ↓∩ C
hB : A ∩ B = B
hC : A ∩ C = C
⊢ B = C
state_after: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hB : A ∩ B = B
hC : A ∩ C = C
h : B = C
⊢ B = C

tactic: exact h
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hB : A ∩ B = B
hC : A ∩ C = C
h : B = C
⊢ B = C
state_after: no goals
Theorem: Metric.eq_of_glueDist_eq_zero
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: rw [eq_of_dist_eq_zero h]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x y : X
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inl y) = 0
⊢ Sum.inl x = Sum.inl y
state_after: no goals

tactic: exfalso
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : X
y : Y
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) = 0
⊢ Sum.inl x = Sum.inr y
state_after: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : X
y : Y
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) = 0
⊢ False

tactic: linarith [le_glueDist_inl_inr Φ Ψ ε x y]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : X
y : Y
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) = 0
⊢ False
state_after: no goals

tactic: exfalso
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : Y
y : X
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y) = 0
⊢ Sum.inr x = Sum.inl y
state_after: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : Y
y : X
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y) = 0
⊢ False

tactic: linarith [le_glueDist_inr_inl Φ Ψ ε x y]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : Y
y : X
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y) = 0
⊢ False
state_after: no goals

tactic: rw [eq_of_dist_eq_zero h]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x y : Y
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inr y) = 0
⊢ Sum.inr x = Sum.inr y
state_after: no goals
Theorem: PMF.support_bindOnSupport
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: refine Set.ext fun b => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
⊢ (p.bindOnSupport f).support = ⋃ a, ⋃ (h : a ∈ p.support), (f a h).support
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ b ∈ (p.bindOnSupport f).support ↔ b ∈ ⋃ a, ⋃ (h : a ∈ p.support), (f a h).support

tactic: simp only [ENNReal.tsum_eq_zero, not_or, mem_support_iff, bindOnSupport_apply, Ne, not_forall,
  mul_eq_zero, Set.mem_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ b ∈ (p.bindOnSupport f).support ↔ b ∈ ⋃ a, ⋃ (h : a ∈ p.support), (f a h).support
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∃ x, ¬p x = 0 ∧ ¬(if h : p x = 0 then 0 else (f x h) b) = 0) ↔ ∃ i, ∃ (h : ¬p i = 0), ¬(f i ⋯) b = 0

tactic: exact
  ⟨fun hb =>
    let ⟨a, ⟨ha, ha'⟩⟩ := hb
    ⟨a, ha, by simpa [ha] using ha'⟩,
    fun hb =>
    let ⟨a, ha, ha'⟩ := hb
    ⟨a, ⟨ha, by simpa [(mem_support_iff _ a).1 ha] using ha'⟩⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∃ x, ¬p x = 0 ∧ ¬(if h : p x = 0 then 0 else (f x h) b) = 0) ↔ ∃ i, ∃ (h : ¬p i = 0), ¬(f i ⋯) b = 0
state_after: no goals

tactic: simpa [ha] using ha'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
hb : ∃ x, ¬p x = 0 ∧ ¬(if h : p x = 0 then 0 else (f x h) b) = 0
a : α
ha : ¬p a = 0
ha' : ¬(if h : p a = 0 then 0 else (f a h) b) = 0
⊢ ¬(f a ⋯) b = 0
state_after: no goals

tactic: simpa [(mem_support_iff _ a).1 ha] using ha'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
hb : ∃ i, ∃ (h : ¬p i = 0), ¬(f i ⋯) b = 0
a : α
ha : ¬p a = 0
ha' : ¬(f a ⋯) b = 0
⊢ ¬(if h : p a = 0 then 0 else (f a h) b) = 0
state_after: no goals
Theorem: RingQuot.sub_quot
File: Mathlib/Algebra/RingQuot.lean

tactic: show sub r _ _ = _
state_before: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ { toQuot := Quot.mk (Rel r) a } - { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a - b) }
state_after: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ RingQuot.sub r { toQuot := Quot.mk (Rel r) a } { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a - b) }

tactic: rw [sub_def]
state_before: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ RingQuot.sub r { toQuot := Quot.mk (Rel r) a } { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a - b) }
state_after: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ (match { toQuot := Quot.mk (Rel r) a }, { toQuot := Quot.mk (Rel r) b } with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ Sub.sub ⋯ ⋯ a b }) =
    { toQuot := Quot.mk (Rel r) (a - b) }

tactic: rfl
state_before: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ (match { toQuot := Quot.mk (Rel r) a }, { toQuot := Quot.mk (Rel r) b } with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ Sub.sub ⋯ ⋯ a b }) =
    { toQuot := Quot.mk (Rel r) (a - b) }
state_after: no goals
Theorem: Module.Ray.map_neg
File: Mathlib/LinearAlgebra/Ray.lean

tactic: induction' v using Module.Ray.ind with g hg
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
f : M ≃ₗ[R] N
v : Ray R M
⊢ (map f) (-v) = -(map f) v
state_after: case h
R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
f : M ≃ₗ[R] N
g : M
hg : g ≠ 0
⊢ (map f) (-rayOfNeZero R g hg) = -(map f) (rayOfNeZero R g hg)

tactic: simp
state_before: case h
R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
f : M ≃ₗ[R] N
g : M
hg : g ≠ 0
⊢ (map f) (-rayOfNeZero R g hg) = -(map f) (rayOfNeZero R g hg)
state_after: no goals
Theorem: Applicative.pure_seq_eq_map'
File: Mathlib/Control/Applicative.lean

tactic: ext
state_before: F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
⊢ (fun x => Seq.seq (pure f) fun x_1 => x) = fun x => f <$> x
state_after: case h
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
x✝ : F α
⊢ (Seq.seq (pure f) fun x => x✝) = f <$> x✝

tactic: simp [functor_norm]
state_before: case h
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
x✝ : F α
⊢ (Seq.seq (pure f) fun x => x✝) = f <$> x✝
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_add_of_mutuallySingular
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: filter_upwards [rnDeriv_add' ν₁ ν₂ μ, (rnDeriv_eq_zero ν₂ μ).mpr h] with x hx_add hx_zero
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
⊢ (ν₁ + ν₂).rnDeriv μ =ᶠ[ae μ] ν₁.rnDeriv μ
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
x : α
hx_add : (ν₁ + ν₂).rnDeriv μ x = (ν₁.rnDeriv μ + ν₂.rnDeriv μ) x
hx_zero : ν₂.rnDeriv μ x = 0 x
⊢ (ν₁ + ν₂).rnDeriv μ x = ν₁.rnDeriv μ x

tactic: simp [hx_add, hx_zero]
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
x : α
hx_add : (ν₁ + ν₂).rnDeriv μ x = (ν₁.rnDeriv μ + ν₂.rnDeriv μ) x
hx_zero : ν₂.rnDeriv μ x = 0 x
⊢ (ν₁ + ν₂).rnDeriv μ x = ν₁.rnDeriv μ x
state_after: no goals
Theorem: unitInterval.half_le_symm_iff
File: Mathlib/Topology/UnitInterval.lean

tactic: rw [coe_symm_eq, le_sub_iff_add_le, add_comm, ← le_sub_iff_add_le, sub_half]
state_before: t : ↑I
⊢ 1 / 2 ≤ ↑(σ t) ↔ ↑t ≤ 1 / 2
state_after: no goals
Theorem: ENNReal.mul_ne_top
File: Mathlib/Data/ENNReal/Operations.lean

tactic: simpa only [lt_top_iff_ne_top] using mul_lt_top
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
⊢ a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤
state_after: no goals