1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.trim
File: Mathlib/MeasureTheory/Measure/Trim.lean

tactic: refine Measure.AbsolutelyContinuous.mk (fun s hs hsν ↦ ?_)
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
⊢ μ.trim hm ≪ ν.trim hm
state_after: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : (ν.trim hm) s = 0
⊢ (μ.trim hm) s = 0

tactic: rw [trim_measurableSet_eq hm hs] at hsν ⊢
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : (ν.trim hm) s = 0
⊢ (μ.trim hm) s = 0
state_after: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : ν s = 0
⊢ μ s = 0

tactic: exact hμν hsν
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : ν s = 0
⊢ μ s = 0
state_after: no goals
Theorem: MeasurableSet.exists_isClosed_diff_lt
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: rcases hA.exists_isClosed_lt_add h'A hε with ⟨F, hFA, hFc, hF⟩
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : OpensMeasurableSpace α
inst✝ : μ.WeaklyRegular
A : Set α
hA : MeasurableSet A
h'A : μ A ≠ ⊤
ε : ℝ≥0∞
hε : ε ≠ 0
⊢ ∃ F ⊆ A, IsClosed F ∧ μ (A \ F) < ε
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : OpensMeasurableSpace α
inst✝ : μ.WeaklyRegular
A : Set α
hA : MeasurableSet A
h'A : μ A ≠ ⊤
ε : ℝ≥0∞
hε : ε ≠ 0
F : Set α
hFA : F ⊆ A
hFc : IsClosed F
hF : μ A < μ F + ε
⊢ ∃ F ⊆ A, IsClosed F ∧ μ (A \ F) < ε

tactic: exact ⟨F, hFA, hFc, measure_diff_lt_of_lt_add hFc.measurableSet hFA
  (ne_top_of_le_ne_top h'A <| measure_mono hFA) hF⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : OpensMeasurableSpace α
inst✝ : μ.WeaklyRegular
A : Set α
hA : MeasurableSet A
h'A : μ A ≠ ⊤
ε : ℝ≥0∞
hε : ε ≠ 0
F : Set α
hFA : F ⊆ A
hFc : IsClosed F
hF : μ A < μ F + ε
⊢ ∃ F ⊆ A, IsClosed F ∧ μ (A \ F) < ε
state_after: no goals
Theorem: Fintype.piFinset_image
File: Mathlib/Data/Fintype/Pi.lean

tactic: ext
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
⊢ (piFinset fun a => image (f a) (s a)) = image (fun b a => f a (b a)) (piFinset s)
state_after: case a
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
a✝ : (a : α) → δ a
⊢ (a✝ ∈ piFinset fun a => image (f a) (s a)) ↔ a✝ ∈ image (fun b a => f a (b a)) (piFinset s)

tactic: simp only [mem_piFinset, mem_image, Classical.skolem, forall_and, Function.funext_iff]
state_before: case a
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : (a : α) → DecidableEq (δ a)
f : (a : α) → γ a → δ a
s : (a : α) → Finset (γ a)
a✝ : (a : α) → δ a
⊢ (a✝ ∈ piFinset fun a => image (f a) (s a)) ↔ a✝ ∈ image (fun b a => f a (b a)) (piFinset s)
state_after: no goals
Theorem: Real.log_neg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← log_one]
state_before: x y : ℝ
h : 0 < x
⊢ log x < 0 ↔ x < 1
state_after: x y : ℝ
h : 0 < x
⊢ log x < log 1 ↔ x < 1

tactic: exact log_lt_log_iff h zero_lt_one
state_before: x y : ℝ
h : 0 < x
⊢ log x < log 1 ↔ x < 1
state_after: no goals
Theorem: Complex.kahler
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: rw [Orientation.kahler_apply_apply]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
w z : ℂ
⊢ (Complex.orientation.kahler w) z = (starRingEnd ℂ) w * z
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
w z : ℂ
⊢ ↑⟪w, z⟫_ℝ + (Complex.orientation.areaForm w) z • I = (starRingEnd ℂ) w * z

tactic: apply Complex.ext <;> simp
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
w z : ℂ
⊢ ↑⟪w, z⟫_ℝ + (Complex.orientation.areaForm w) z • I = (starRingEnd ℂ) w * z
state_after: no goals
Theorem: NNReal.isConjExponent_coe
File: Mathlib/Data/Real/ConjExponents.lean

tactic: simp [Real.isConjExponent_iff, isConjExponent_iff]
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ (↑p).IsConjExponent ↑q ↔ p.IsConjExponent q
state_after: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → ((↑p)⁻¹ + (↑q)⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)

tactic: norm_cast
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → ((↑p)⁻¹ + (↑q)⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
state_after: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → (p⁻¹ + q⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)

tactic: simp
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → (p⁻¹ + q⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
state_after: no goals
Theorem: Finset.sum_pow
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: conv_rhs => rw [← sum_coe_sort]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ k ∈ s.sym n, ↑(↑k).multinomial * (Multiset.map x ↑k).prod
state_after: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ i : { x // x ∈ s.sym n }, ↑(↑↑i).multinomial * (Multiset.map x ↑↑i).prod

tactic: convert sum_pow_of_commute s x (fun _ _ _ _ _ => mul_comm _ _) n
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ i : { x // x ∈ s.sym n }, ↑(↑↑i).multinomial * (Multiset.map x ↑↑i).prod
state_after: case h.e'_3.a.h.e'_6
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : CommSemiring R
x : α → R
n : ℕ
x✝ : { x // x ∈ s.sym n }
a✝ : x✝ ∈ univ
⊢ (Multiset.map x ↑↑x✝).prod = (Multiset.map x ↑↑x✝).noncommProd ⋯

tactic: rw [Multiset.noncommProd_eq_prod]
state_before: case h.e'_3.a.h.e'_6
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : CommSemiring R
x : α → R
n : ℕ
x✝ : { x // x ∈ s.sym n }
a✝ : x✝ ∈ univ
⊢ (Multiset.map x ↑↑x✝).prod = (Multiset.map x ↑↑x✝).noncommProd ⋯
state_after: no goals
Theorem: isBigO_riemannZeta_sub_one_div
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

tactic: simpa only [Asymptotics.isBigO_one_nhds_ne_iff] using
   tendsto_riemannZeta_sub_one_div.isBigO_one (F := F)
state_before: F : Type u_1
inst✝² : Norm F
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (fun s => riemannZeta s - 1 / (s - 1)) =O[𝓝 1] fun x => 1
state_after: no goals
Theorem: compactSpace_of_finite_subfamily_closed
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simpa using h t
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
h : ∀ {ι : Type u} (t : ι → Set X), (∀ (i : ι), IsClosed (t i)) → ⋂ i, t i = ∅ → ∃ u, ⋂ i ∈ u, t i = ∅
ι✝ : Type u
t : ι✝ → Set X
⊢ (∀ (i : ι✝), IsClosed (t i)) → univ ∩ ⋂ i, t i = ∅ → ∃ u, univ ∩ ⋂ i ∈ u, t i = ∅
state_after: no goals
Theorem: Stream'.cycle_singleton
File: Mathlib/Data/Stream/Init.lean

tactic: simp
state_before: α : Type u
β : Type v
δ : Type w
a : α
⊢ [a] ≠ []
state_after: no goals

tactic: rwa [cycle_eq, const_eq]
state_before: α : Type u
β✝ : Type v
δ : Type w
a : α
β : Type u
fr : Stream' α → β
ch : fr (cycle [a] ⋯) = fr (const a)
⊢ fr (cycle [a] ⋯).tail = fr (const a).tail
state_after: no goals
Theorem: GeneralizedContinuedFraction.zeroth_convergent'_eq_h
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [convergents']
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
⊢ g.convergents' 0 = g.h
state_after: no goals
Theorem: pow_eq_one_iff_of_nonneg
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simpa only [one_pow] using pow_left_inj ha zero_le_one hn
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha : 0 ≤ a
hn : n ≠ 0
⊢ a ^ n = 1 ↔ a = 1
state_after: no goals
Theorem: CategoryTheory.IsPullback.isoPullback_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: dsimp [isoPullback, cone, CommSq.cone]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
h : IsPullback fst snd f g
inst✝ : HasPullback f g
⊢ h.isoPullback.hom ≫ pullback.snd = snd
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
h : IsPullback fst snd f g
inst✝ : HasPullback f g
⊢ (limit.isoLimitCone { cone := PullbackCone.mk fst snd ⋯, isLimit := h.isLimit }).inv ≫ pullback.snd = snd

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
h : IsPullback fst snd f g
inst✝ : HasPullback f g
⊢ (limit.isoLimitCone { cone := PullbackCone.mk fst snd ⋯, isLimit := h.isLimit }).inv ≫ pullback.snd = snd
state_after: no goals
Theorem: PosNum.pred_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: unfold pred
state_before: n : PosNum
h : 1 < n
⊢ ↑n.pred = (↑n).pred
state_after: n : PosNum
h : 1 < n
⊢ ↑(Num.casesOn n.pred' 1 id) = (↑n).pred

tactic: cases e : pred' n
state_before: n : PosNum
h : 1 < n
⊢ ↑(Num.casesOn n.pred' 1 id) = (↑n).pred
state_after: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred

case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : n.pred' = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = (↑n).pred

tactic: have : (1 : ℕ) ≤ Nat.pred n := Nat.pred_le_pred ((@cast_lt ℕ _ _ _).2 h)
state_before: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred
state_after: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
this : 1 ≤ (↑n).pred
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred

tactic: rw [← pred'_to_nat, e] at this
state_before: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
this : 1 ≤ (↑n).pred
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred
state_after: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
this : 1 ≤ ↑zero
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred

tactic: exact absurd this (by decide)
state_before: case zero
n : PosNum
h : 1 < n
e : n.pred' = zero
this : 1 ≤ ↑zero
⊢ ↑(Num.casesOn zero 1 id) = (↑n).pred
state_after: no goals

tactic: decide
state_before: n : PosNum
h : 1 < n
e : n.pred' = zero
this : 1 ≤ ↑zero
⊢ ¬1 ≤ ↑zero
state_after: no goals

tactic: rw [← pred'_to_nat, e]
state_before: case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : n.pred' = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = (↑n).pred
state_after: case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : n.pred' = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = ↑(pos a✝)

tactic: rfl
state_before: case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : n.pred' = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = ↑(pos a✝)
state_after: no goals
Theorem: Disjoint.symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint (a ∆ b) c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) c

tactic: exact (ha.sup_left hb).disjoint_sdiff_left
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) c
state_after: no goals
Theorem: DFinsupp.prod_subtypeDomain_index
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: refine Finset.prod_bij (fun p _ ↦ p) ?_ ?_ ?_ ?_ <;> aesop
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : CommMonoid γ
v : Π₀ (i : ι), β i
p : ι → Prop
inst✝ : DecidablePred p
h : (i : ι) → β i → γ
hp : ∀ x ∈ v.support, p x
⊢ ((subtypeDomain p v).prod fun i b => h (↑i) b) = v.prod h
state_after: no goals
Theorem: Surreal.Multiplication.ih₁₂
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [IH24]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
⊢ IH24 x₁ x₂ y
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
⊢ ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)

tactic: refine fun z ↦ ⟨?_, ?_, ?_⟩ <;>
  refine fun h ↦ ih' (Args.P24 _ _ _) (TransGen.single ?_)
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
⊢ ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
state_after: case refine_1
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption x₁
⊢ CutExpand IsOption (Args.P24 z x₂ y).toMultiset (Args.P24 x₁ x₂ y).toMultiset

case refine_2
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption x₂
⊢ CutExpand IsOption (Args.P24 x₁ z y).toMultiset (Args.P24 x₁ x₂ y).toMultiset

case refine_3
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption y
⊢ CutExpand IsOption (Args.P24 x₁ x₂ z).toMultiset (Args.P24 x₁ x₂ y).toMultiset

tactic: exact (cutExpand_add_right {y}).2 (cutExpand_pair_left h)
state_before: case refine_1
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption x₁
⊢ CutExpand IsOption (Args.P24 z x₂ y).toMultiset (Args.P24 x₁ x₂ y).toMultiset
state_after: no goals

tactic: exact (cutExpand_add_left {x₁}).2 (cutExpand_pair_left h)
state_before: case refine_2
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption x₂
⊢ CutExpand IsOption (Args.P24 x₁ z y).toMultiset (Args.P24 x₁ x₂ y).toMultiset
state_after: no goals

tactic: exact (cutExpand_add_left {x₁}).2 (cutExpand_pair_right h)
state_before: case refine_3
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
z : PGame
h : z.IsOption y
⊢ CutExpand IsOption (Args.P24 x₁ x₂ z).toMultiset (Args.P24 x₁ x₂ y).toMultiset
state_after: no goals
Theorem: Filter.lift_lift'_assoc
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [lift_principal, hh, eq_self_iff_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
h✝ h₁ h₂ g : Set α → Set β
h : Set β → Filter γ
hg : Monotone g
hh : Monotone h
⊢ (f.lift fun s => (𝓟 (g s)).lift h) = f.lift fun s => h (g s)
state_after: no goals
Theorem: Equiv.extendSubtype_not_mem
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: convert (e.toCompl ⟨x, hx⟩).2
state_before: α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ¬q (e.extendSubtype x)
state_after: case h.e'_1.h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ e.extendSubtype x = ↑(e.toCompl ⟨x, hx⟩)

tactic: rw [e.extendSubtype_apply_of_not_mem _ hx]
state_before: case h.e'_1.h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ e.extendSubtype x = ↑(e.toCompl ⟨x, hx⟩)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.dblU_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [dblU_eq, hPz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.dblU P = -3 * P x ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.a₁ * P y * 0 - (3 * P x ^ 2 + 2 * W'.a₂ * P x * 0 ^ 2 + W'.a₄ * 0 ^ 4) = -3 * P x ^ 2

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.a₁ * P y * 0 - (3 * P x ^ 2 + 2 * W'.a₂ * P x * 0 ^ 2 + W'.a₄ * 0 ^ 4) = -3 * P x ^ 2
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.rightOp
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

tactic: haveI := h f.op hf
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : W.op.IsInvertedBy L
X Y : C
f : X ⟶ Y
hf : W f
⊢ IsIso (L.rightOp.map f)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : W.op.IsInvertedBy L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.rightOp.map f)

tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : W.op.IsInvertedBy L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.rightOp.map f)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : W.op.IsInvertedBy L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.map f.op).op

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : W.op.IsInvertedBy L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.map f.op).op
state_after: no goals
Theorem: IsPrimitiveRoot.minpoly_dvd_x_pow_sub_one
File: Mathlib/RingTheory/RootsOfUnity/Minpoly.lean

tactic: rcases n.eq_zero_or_pos with (rfl | h0)
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
⊢ minpoly ℤ μ ∣ X ^ n - 1
state_after: case inl
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
h : IsPrimitiveRoot μ 0
⊢ minpoly ℤ μ ∣ X ^ 0 - 1

case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ minpoly ℤ μ ∣ X ^ n - 1

tactic: apply minpoly.isIntegrallyClosed_dvd (isIntegral h h0)
state_before: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ minpoly ℤ μ ∣ X ^ n - 1
state_after: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ (Polynomial.aeval μ) (X ^ n - 1) = 0

tactic: simp only [((IsPrimitiveRoot.iff_def μ n).mp h).left, aeval_X_pow, eq_intCast, Int.cast_one,
  aeval_one, AlgHom.map_sub, sub_self]
state_before: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ (Polynomial.aeval μ) (X ^ n - 1) = 0
state_after: no goals

tactic: simp
state_before: case inl
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
h : IsPrimitiveRoot μ 0
⊢ minpoly ℤ μ ∣ X ^ 0 - 1
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.of_nonpos_disjoint_union_eq_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [of_union h hA₁ hB₁] at hAB
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
s : SignedMeasure α
A B : Set α
h : Disjoint A B
hA₁ : MeasurableSet A
hB₁ : MeasurableSet B
hA₂ : ↑s A ≤ 0
hB₂ : ↑s B ≤ 0
hAB : ↑s (A ∪ B) = 0
⊢ ↑s A = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
s : SignedMeasure α
A B : Set α
h : Disjoint A B
hA₁ : MeasurableSet A
hB₁ : MeasurableSet B
hA₂ : ↑s A ≤ 0
hB₂ : ↑s B ≤ 0
hAB : ↑s A + ↑s B = 0
⊢ ↑s A = 0

tactic: linarith
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
s : SignedMeasure α
A B : Set α
h : Disjoint A B
hA₁ : MeasurableSet A
hB₁ : MeasurableSet B
hA₂ : ↑s A ≤ 0
hB₂ : ↑s B ≤ 0
hAB : ↑s A + ↑s B = 0
⊢ ↑s A = 0
state_after: no goals
Theorem: Batteries.UnionFind.parent_root
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: rw [root]
state_before: self : UnionFind
x : Fin self.size
⊢ (self.arr.get (self.root x)).parent = ↑(self.root x)
state_after: self : UnionFind
x : Fin self.size
⊢ (self.arr.get
        (if h : (self.arr.get x).parent = ↑x then x
        else
          let_fun this := ⋯;
          self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(if h : (self.arr.get x).parent = ↑x then x
      else
        let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)

tactic: split <;> [assumption; skip]
state_before: self : UnionFind
x : Fin self.size
⊢ (self.arr.get
        (if h : (self.arr.get x).parent = ↑x then x
        else
          let_fun this := ⋯;
          self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(if h : (self.arr.get x).parent = ↑x then x
      else
        let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)
state_after: case isFalse
self : UnionFind
x : Fin self.size
h✝ : ¬(self.arr.get x).parent = ↑x
⊢ (self.arr.get
        (let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(let_fun this := ⋯;
      self.root ⟨(self.arr.get x).parent, ⋯⟩)

tactic: have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
state_before: case isFalse
self : UnionFind
x : Fin self.size
h✝ : ¬(self.arr.get x).parent = ↑x
⊢ (self.arr.get
        (let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(let_fun this := ⋯;
      self.root ⟨(self.arr.get x).parent, ⋯⟩)
state_after: case isFalse
self : UnionFind
x : Fin self.size
h✝ : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ (self.arr.get
        (let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(let_fun this := ⋯;
      self.root ⟨(self.arr.get x).parent, ⋯⟩)

tactic: apply parent_root
state_before: case isFalse
self : UnionFind
x : Fin self.size
h✝ : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ (self.arr.get
        (let_fun this := ⋯;
        self.root ⟨(self.arr.get x).parent, ⋯⟩)).parent =
    ↑(let_fun this := ⋯;
      self.root ⟨(self.arr.get x).parent, ⋯⟩)
state_after: no goals