1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PMF.toOuterMeasure_pure_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: refine (toOuterMeasure_apply (pure a) s).trans ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ (pure a).toOuterMeasure s = if a ∈ s then 1 else 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = if a ∈ s then 1 else 0

tactic: split_ifs with ha
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = if a ∈ s then 1 else 0
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∈ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 1

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∉ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 0

tactic: refine (tsum_congr fun b => ?_).trans (tsum_ite_eq a 1)
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∈ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 1
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∈ s
b : α
⊢ s.indicator (⇑(pure a)) b = if b = a then 1 else 0

tactic: exact ite_eq_left_iff.2 fun hb => symm (ite_eq_right_iff.2 fun h => (hb <| h.symm ▸ ha).elim)
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∈ s
b : α
⊢ s.indicator (⇑(pure a)) b = if b = a then 1 else 0
state_after: no goals

tactic: refine (tsum_congr fun b => ?_).trans tsum_zero
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∉ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 0
state_after: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∉ s
b : α
⊢ s.indicator (⇑(pure a)) b = 0

tactic: exact ite_eq_right_iff.2 fun hb => ite_eq_right_iff.2 fun h => (ha <| h ▸ hb).elim
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∉ s
b : α
⊢ s.indicator (⇑(pure a)) b = 0
state_after: no goals
Theorem: inf_sdiff_distrib_right
File: Mathlib/Order/BooleanAlgebra.lean

tactic: simp_rw [inf_comm _ c, inf_sdiff_distrib_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
a b c : α
⊢ a \ b ⊓ c = (a ⊓ c) \ (b ⊓ c)
state_after: no goals
Theorem: normSq_eq_of_mem_circle
File: Mathlib/Analysis/Complex/Circle.lean

tactic: simp [normSq_eq_abs]
state_before: z : ↥circle
⊢ normSq ↑z = 1
state_after: no goals
Theorem: PMF.bind_comm
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simpa only [ENNReal.coe_inj.symm, bind_apply, ENNReal.tsum_mul_left.symm,
  ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : α → PMF β
g : β → PMF γ
p : PMF α
q : PMF β
f : α → β → PMF γ
b : γ
⊢ (p.bind fun a => q.bind (f a)) b = (q.bind fun b => p.bind fun a => f a b) b
state_after: no goals
Theorem: LinearIsometry.norm_iteratedFDeriv_comp_left
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDeriv 𝕜 i (⇑g ∘ f) x‖ = ‖iteratedFDeriv 𝕜 i f x‖
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDerivWithin 𝕜 i (⇑g ∘ f) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ x‖

tactic: exact g.norm_iteratedFDerivWithin_comp_left hf.contDiffOn uniqueDiffOn_univ (mem_univ x) hi
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDerivWithin 𝕜 i (⇑g ∘ f) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ x‖
state_after: no goals
Theorem: CharTwo.two_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [← Nat.cast_two, CharP.cast_eq_zero]
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : Semiring R
inst✝ : CharP R 2
⊢ 2 = 0
state_after: no goals
Theorem: NumberField.det_basisOfFractionalIdeal_eq_absNorm
File: Mathlib/NumberTheory/NumberField/FractionalIdeal.lean

tactic: rw [← FractionalIdeal.abs_det_basis_change (RingOfIntegers.basis K) I.1
  ((fractionalIdealBasis K I.1).reindex e.symm)]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ |(integralBasis K).det ⇑((basisOfFractionalIdeal K I).reindex e.symm)| = FractionalIdeal.absNorm ↑I
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ |(integralBasis K).det ⇑((basisOfFractionalIdeal K I).reindex e.symm)| =
    |(Basis.localizationLocalization ℚ ℤ⁰ K (RingOfIntegers.basis K)).det
        (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm))|

tactic: congr
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ |(integralBasis K).det ⇑((basisOfFractionalIdeal K I).reindex e.symm)| =
    |(Basis.localizationLocalization ℚ ℤ⁰ K (RingOfIntegers.basis K)).det
        (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm))|
state_after: case e_a.h.e_6.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ ⇑((basisOfFractionalIdeal K I).reindex e.symm) = Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)

tactic: ext
state_before: case e_a.h.e_6.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ ⇑((basisOfFractionalIdeal K I).reindex e.symm) = Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)
state_after: case e_a.h.e_6.h.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
x✝ : Free.ChooseBasisIndex ℤ (𝓞 K)
⊢ ((basisOfFractionalIdeal K I).reindex e.symm) x✝ = (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)) x✝

tactic: simpa using basisOfFractionalIdeal_apply K I _
state_before: case e_a.h.e_6.h.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
x✝ : Free.ChooseBasisIndex ℤ (𝓞 K)
⊢ ((basisOfFractionalIdeal K I).reindex e.symm) x✝ = (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)) x✝
state_after: no goals
Theorem: CategoryTheory.NatIso.ofComponents.app
File: Mathlib/CategoryTheory/NatIso.lean

tactic: aesop
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
app' : (X : C) → F.obj X ≅ G.obj X
naturality : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app' Y).hom = (app' X).hom ≫ G.map f
X : C
⊢ (ofComponents app' naturality).app X = app' X
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.homMk'_mk_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ T.obj Y
⊢ mk f = mk ((mk f).hom ≫ T.map (𝟙 Y))
state_after: no goals
Theorem: Filter.map_add_atTop_eq_nat
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [tsub_add_cancel_of_le h]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
k a : ℕ
h : a ≥ k
⊢ a ≤ (fun a => a - k) a + k
state_after: no goals
Theorem: LinearEquiv.det_coe_symm
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: field_simp [IsUnit.ne_zero f.isUnit_det']
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type u_3
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_4
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
𝕜 : Type u_5
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M ≃ₗ[𝕜] M
⊢ LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹
state_after: no goals
Theorem: MeasureTheory.sub_eq_zero_of_upcrossingsBefore_lt
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: have : N ≤ upperCrossingTime a b f N n ω := by
  rw [upcrossingsBefore] at hn
  rw [← not_lt]
  exact fun h => not_le.2 hn (le_csSup (upperCrossingTime_lt_bddAbove hab) h)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : upcrossingsBefore a b f N ω < n
⊢ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω - stoppedValue f (lowerCrossingTime a b f N n) ω = 0
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : upcrossingsBefore a b f N ω < n
this : N ≤ upperCrossingTime a b f N n ω
⊢ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω - stoppedValue f (lowerCrossingTime a b f N n) ω = 0

tactic: simp [stoppedValue, upperCrossingTime_stabilize' (Nat.le_succ n) this,
  lowerCrossingTime_stabilize' le_rfl (le_trans this upperCrossingTime_le_lowerCrossingTime)]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : upcrossingsBefore a b f N ω < n
this : N ≤ upperCrossingTime a b f N n ω
⊢ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω - stoppedValue f (lowerCrossingTime a b f N n) ω = 0
state_after: no goals

tactic: rw [upcrossingsBefore] at hn
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : upcrossingsBefore a b f N ω < n
⊢ N ≤ upperCrossingTime a b f N n ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : sSup {n | upperCrossingTime a b f N n ω < N} < n
⊢ N ≤ upperCrossingTime a b f N n ω

tactic: rw [← not_lt]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : sSup {n | upperCrossingTime a b f N n ω < N} < n
⊢ N ≤ upperCrossingTime a b f N n ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : sSup {n | upperCrossingTime a b f N n ω < N} < n
⊢ ¬upperCrossingTime a b f N n ω < N

tactic: exact fun h => not_le.2 hn (le_csSup (upperCrossingTime_lt_bddAbove hab) h)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
hn : sSup {n | upperCrossingTime a b f N n ω < N} < n
⊢ ¬upperCrossingTime a b f N n ω < N
state_after: no goals
Theorem: EllipticCurve.ofJ_0_of_three_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: rw [ofJ, dif_pos rfl, dif_pos h3]
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
F : Type u
inst✝¹ : Field F
j : F
inst✝ : DecidableEq F
h3 : 3 = 0
⊢ ofJ 0 = ofJ1728 F
state_after: no goals
Theorem: Polynomial.hermite_eq_deriv_gaussian'
File: Mathlib/RingTheory/Polynomial/Hermite/Gaussian.lean

tactic: rw [hermite_eq_deriv_gaussian, Real.exp_neg]
state_before: n : ℕ
x : ℝ
⊢ (aeval x) (hermite n) = (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2)
state_after: n : ℕ
x : ℝ
⊢ (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / (Real.exp (x ^ 2 / 2))⁻¹ =
    (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2)

tactic: field_simp [Real.exp_ne_zero]
state_before: n : ℕ
x : ℝ
⊢ (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / (Real.exp (x ^ 2 / 2))⁻¹ =
    (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2)
state_after: no goals
Theorem: Finset.replicate_mem_sym
File: Mathlib/Data/Finset/Sym.lean

tactic: rwa [(Sym.mem_replicate.1 hb).2]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b✝ : α
n✝ : ℕ
ha : a ∈ s
n : ℕ
b : α
hb : b ∈ Sym.replicate n a
⊢ b ∈ s
state_after: no goals
Theorem: Set.add_mem_center
File: Mathlib/Algebra/Ring/Center.lean

tactic: rw [add_mul, mul_add, ha.comm, hb.comm]
state_before: M : Type u_1
inst✝ : Distrib M
a b : M
ha : a ∈ center M
hb : b ∈ center M
x✝ : M
⊢ (a + b) * x✝ = x✝ * (a + b)
state_after: no goals

tactic: rw [add_mul, ha.left_assoc, hb.left_assoc, ← add_mul, ← add_mul]
state_before: M : Type u_1
inst✝ : Distrib M
a b : M
ha : a ∈ center M
hb : b ∈ center M
x✝¹ x✝ : M
⊢ (a + b) * (x✝¹ * x✝) = (a + b) * x✝¹ * x✝
state_after: no goals

tactic: rw [mul_add, add_mul, ha.mid_assoc, hb.mid_assoc, ← mul_add, ← add_mul]
state_before: M : Type u_1
inst✝ : Distrib M
a b : M
ha : a ∈ center M
hb : b ∈ center M
x✝¹ x✝ : M
⊢ x✝¹ * (a + b) * x✝ = x✝¹ * ((a + b) * x✝)
state_after: no goals

tactic: rw [mul_add, ha.right_assoc, hb.right_assoc, ← mul_add, ← mul_add]
state_before: M : Type u_1
inst✝ : Distrib M
a b : M
ha : a ∈ center M
hb : b ∈ center M
x✝¹ x✝ : M
⊢ x✝¹ * x✝ * (a + b) = x✝¹ * (x✝ * (a + b))
state_after: no goals
Theorem: MvPolynomial.eval₂Hom_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp only [monomial_eq, RingHom.map_mul, eval₂Hom_C, Finsupp.prod, map_prod,
  RingHom.map_pow, eval₂Hom_X']
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f✝ : R →+* S₁
g✝ : σ → S₁
f : R →+* S₁
g : σ → S₁
d : σ →₀ ℕ
r : R
⊢ (eval₂Hom f g) ((monomial d) r) = f r * d.prod fun i k => g i ^ k
state_after: no goals
Theorem: SimpleGraph.chromaticNumber_top_eq_top_of_infinite
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: by_contra hc
state_before: V✝ : Type u
G : SimpleGraph V✝
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
⊢ ⊤.chromaticNumber = ⊤
state_after: V✝ : Type u
G : SimpleGraph V✝
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
hc : ¬⊤.chromaticNumber = ⊤
⊢ False

tactic: rw [← Ne, chromaticNumber_ne_top_iff_exists] at hc
state_before: V✝ : Type u
G : SimpleGraph V✝
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
hc : ¬⊤.chromaticNumber = ⊤
⊢ False
state_after: V✝ : Type u
G : SimpleGraph V✝
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
hc : ∃ n, ⊤.Colorable n
⊢ False

tactic: obtain ⟨n, ⟨hn⟩⟩ := hc
state_before: V✝ : Type u
G : SimpleGraph V✝
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
hc : ∃ n, ⊤.Colorable n
⊢ False
state_after: case intro.intro
V✝ : Type u
G : SimpleGraph V✝
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
n : ℕ
hn : ⊤.Coloring (Fin n)
⊢ False

tactic: exact not_injective_infinite_finite _ hn.injective_of_top_hom
state_before: case intro.intro
V✝ : Type u
G : SimpleGraph V✝
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V : Type u_3
inst✝ : Infinite V
n : ℕ
hn : ⊤.Coloring (Fin n)
⊢ False
state_after: no goals
Theorem: Odd.zpow_nonpos_iff
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: rw [le_iff_lt_or_eq, le_iff_lt_or_eq, hn.zpow_neg_iff, zpow_eq_zero_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : Odd n
⊢ a ^ n ≤ 0 ↔ a ≤ 0
state_after: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : Odd n
⊢ n ≠ 0

tactic: rintro rfl
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : Odd n
⊢ n ≠ 0
state_after: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
hn : Odd 0
⊢ False

tactic: exact Int.odd_iff_not_even.1 hn even_zero
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
hn : Odd 0
⊢ False
state_after: no goals
Theorem: Set.image2_empty_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ∀ (x : γ), x ∈ image2 f ∅ t ↔ x ∈ ∅
state_after: no goals
Theorem: AddSubmonoid.fg_iff_mul_fg
File: Mathlib/GroupTheory/Finiteness.lean

tactic: convert (Submonoid.fg_iff_add_fg (toSubmonoid P)).symm
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : AddSubmonoid N
⊢ P.FG ↔ (toSubmonoid P).FG
state_after: no goals
Theorem: HurwitzZeta.sinZeta_one_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: rw [← Gammaℂ, sinZeta, (by ring : 1 - s + 1 = 2 - s), div_eq_mul_inv, inv_Gammaℝ_two_sub hs,
  completedSinZeta_one_sub, hurwitzZetaOdd, ← div_eq_mul_inv, ← mul_div_assoc, ← mul_div_assoc,
  mul_comm]
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
⊢ sinZeta a (1 - s) = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.sin (↑π * s / 2) * hurwitzZetaOdd a s
state_after: no goals

tactic: ring
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
⊢ 1 - s + 1 = 2 - s
state_after: no goals
Theorem: Int.succ_natCast_pos
File: Mathlib/Data/Int/Lemmas.lean

tactic: simp
state_before: n : ℕ
⊢ 0 ≤ ↑n
state_after: no goals
Theorem: Set.SurjOn.leftInvOn_of_rightInvOn
File: Mathlib/Data/Set/Function.lean

tactic: let ⟨x, hx, heq⟩ := hf hy
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
⊢ f (f' y) = y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
x : α
hx : x ∈ s
heq : f x = y
⊢ f (f' y) = y

tactic: rw [← heq, hf' hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
x : α
hx : x ∈ s
heq : f x = y
⊢ f (f' y) = y
state_after: no goals
Theorem: Rat.mkRat_pow
File: Mathlib/Algebra/Ring/Rat.lean

tactic: rw [mkRat_eq_divInt, mkRat_eq_divInt, divInt_pow, Int.natCast_pow]
state_before: num den n : ℕ
⊢ mkRat (↑num) den ^ n = mkRat (↑num ^ n) (den ^ n)
state_after: no goals
Theorem: List.foldr_ext
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
l : List α
H : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b
⊢ foldr f b l = foldr g b l
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
H : ∀ (a : α), a ∈ [] → ∀ (b : β), f a b = g a b
⊢ foldr f b [] = foldr g b []

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : ∀ (a : α), a ∈ hd :: tl → ∀ (b : β), f a b = g a b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)

tactic: simp only [mem_cons, or_imp, forall_and, forall_eq] at H
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : ∀ (a : α), a ∈ hd :: tl → ∀ (b : β), f a b = g a b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : (∀ (b : β), f hd b = g hd b) ∧ ∀ (x : α), x ∈ tl → ∀ (b : β), f x b = g x b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)

tactic: simp only [foldr, ih H.2, H.1]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : (∀ (b : β), f hd b = g hd b) ∧ ∀ (x : α), x ∈ tl → ∀ (b : β), f x b = g x b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)
state_after: no goals

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → β
b : β
H : ∀ (a : α), a ∈ [] → ∀ (b : β), f a b = g a b
⊢ foldr f b [] = foldr g b []
state_after: no goals
Theorem: MeasureTheory.SigmaFinite.of_map
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simp only [← map_apply_of_aemeasurable hf, measurable_spanningSets,
  measure_spanningSets_lt_top]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
f : α → β
hf : AEMeasurable f μ
h : SigmaFinite (Measure.map f μ)
n : ℕ
⊢ μ ((fun n => f ⁻¹' spanningSets (Measure.map f μ) n) n) < ⊤
state_after: no goals

tactic: rw [← preimage_iUnion, iUnion_spanningSets, preimage_univ]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
f : α → β
hf : AEMeasurable f μ
h : SigmaFinite (Measure.map f μ)
⊢ ⋃ i, (fun n => f ⁻¹' spanningSets (Measure.map f μ) n) i = univ
state_after: no goals