1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HasFPowerSeriesAt.congr
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rcases hf with ⟨r₁, h₁⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesAt f p x
hg : f =ᶠ[𝓝 x] g
⊢ HasFPowerSeriesAt g p x
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hg : f =ᶠ[𝓝 x] g
r₁ : ℝ≥0∞
h₁ : HasFPowerSeriesOnBall f p x r₁
⊢ HasFPowerSeriesAt g p x

tactic: rcases EMetric.mem_nhds_iff.mp hg with ⟨r₂, h₂pos, h₂⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hg : f =ᶠ[𝓝 x] g
r₁ : ℝ≥0∞
h₁ : HasFPowerSeriesOnBall f p x r₁
⊢ HasFPowerSeriesAt g p x
state_after: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hg : f =ᶠ[𝓝 x] g
r₁ : ℝ≥0∞
h₁ : HasFPowerSeriesOnBall f p x r₁
r₂ : ℝ≥0∞
h₂pos : r₂ > 0
h₂ : EMetric.ball x r₂ ⊆ {x | (fun x => f x = g x) x}
⊢ HasFPowerSeriesAt g p x

tactic: exact ⟨min r₁ r₂,
  (h₁.mono (lt_min h₁.r_pos h₂pos) inf_le_left).congr
    fun y hy => h₂ (EMetric.ball_subset_ball inf_le_right hy)⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hg : f =ᶠ[𝓝 x] g
r₁ : ℝ≥0∞
h₁ : HasFPowerSeriesOnBall f p x r₁
r₂ : ℝ≥0∞
h₂pos : r₂ > 0
h₂ : EMetric.ball x r₂ ⊆ {x | (fun x => f x = g x) x}
⊢ HasFPowerSeriesAt g p x
state_after: no goals
Theorem: CategoryTheory.Functor.FullyFaithful.hasShift.map_add_hom_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: dsimp [add]
state_before: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map ((add hF s i a b).hom.app X) =
    (i (a + b)).hom.app X ≫
      (shiftFunctorAdd D a b).hom.app (F.obj X) ≫ (shiftFunctor D b).map ((i a).inv.app X) ≫ (i b).inv.app ((s a).obj X)
state_after: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map
      (hF.preimage
        ((i (a + b)).hom.app X ≫
          (shiftFunctorAdd D a b).hom.app (F.obj X) ≫
            𝟙 ((shiftFunctor D b).obj ((shiftFunctor D a).obj (F.obj X))) ≫
              (shiftFunctor D b).map ((i a).inv.app X) ≫
                𝟙 ((shiftFunctor D b).obj (F.obj ((s a).obj X))) ≫
                  (i b).inv.app ((s a).obj X) ≫ 𝟙 (F.obj ((s b).obj ((s a).obj X))))) =
    (i (a + b)).hom.app X ≫
      (shiftFunctorAdd D a b).hom.app (F.obj X) ≫ (shiftFunctor D b).map ((i a).inv.app X) ≫ (i b).inv.app ((s a).obj X)

tactic: simp
state_before: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map
      (hF.preimage
        ((i (a + b)).hom.app X ≫
          (shiftFunctorAdd D a b).hom.app (F.obj X) ≫
            𝟙 ((shiftFunctor D b).obj ((shiftFunctor D a).obj (F.obj X))) ≫
              (shiftFunctor D b).map ((i a).inv.app X) ≫
                𝟙 ((shiftFunctor D b).obj (F.obj ((s a).obj X))) ≫
                  (i b).inv.app ((s a).obj X) ≫ 𝟙 (F.obj ((s b).obj ((s a).obj X))))) =
    (i (a + b)).hom.app X ≫
      (shiftFunctorAdd D a b).hom.app (F.obj X) ≫ (shiftFunctor D b).map ((i a).inv.app X) ≫ (i b).inv.app ((s a).obj X)
state_after: no goals
Theorem: MeasureTheory.Measure.MutuallySingular.mk
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: use toMeasurable μ s, measurableSet_toMeasurable _ _, (measure_toMeasurable _).trans hs
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : μ s = 0
ht : ν t = 0
hst : univ ⊆ s ∪ t
⊢ μ ⟂ₘ ν
state_after: case right
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : μ s = 0
ht : ν t = 0
hst : univ ⊆ s ∪ t
⊢ ν (toMeasurable μ s)ᶜ = 0

tactic: refine measure_mono_null (fun x hx => (hst trivial).resolve_left fun hxs => hx ?_) ht
state_before: case right
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : μ s = 0
ht : ν t = 0
hst : univ ⊆ s ∪ t
⊢ ν (toMeasurable μ s)ᶜ = 0
state_after: case right
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : μ s = 0
ht : ν t = 0
hst : univ ⊆ s ∪ t
x : α
hx : x ∈ (toMeasurable μ s)ᶜ
hxs : x ∈ s
⊢ x ∈ toMeasurable μ s

tactic: exact subset_toMeasurable _ _ hxs
state_before: case right
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : μ s = 0
ht : ν t = 0
hst : univ ⊆ s ∪ t
x : α
hx : x ∈ (toMeasurable μ s)ᶜ
hxs : x ∈ s
⊢ x ∈ toMeasurable μ s
state_after: no goals
Theorem: ContinuousWithinAt.partialSups
File: Mathlib/Topology/Order/PartialSups.lean

tactic: simpa only [← partialSups_apply] using ContinuousWithinAt.partialSups_apply hf
state_before: L : Type u_1
inst✝³ : SemilatticeSup L
inst✝² : TopologicalSpace L
inst✝¹ : ContinuousSup L
X : Type u_2
inst✝ : TopologicalSpace X
f : ℕ → X → L
n : ℕ
s : Set X
x : X
hf : ∀ k ≤ n, ContinuousWithinAt (f k) s x
⊢ ContinuousWithinAt ((partialSups f) n) s x
state_after: no goals
Theorem: Nat.dvd_of_forall_prime_mul_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: obtain rfl | ha := eq_or_ne a 1
state_before: n a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
⊢ a ∣ b
state_after: case inl
n b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ 1 → p * 1 ∣ b
⊢ 1 ∣ b

case inr
n a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
⊢ a ∣ b

tactic: obtain ⟨p, hp⟩ := exists_prime_and_dvd ha
state_before: case inr
n a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
⊢ a ∣ b
state_after: case inr.intro
n a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
p : ℕ
hp : Prime p ∧ p ∣ a
⊢ a ∣ b

tactic: exact _root_.trans (dvd_mul_left a p) (hdvd p hp.1 hp.2)
state_before: case inr.intro
n a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
p : ℕ
hp : Prime p ∧ p ∣ a
⊢ a ∣ b
state_after: no goals

tactic: apply one_dvd
state_before: case inl
n b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ 1 → p * 1 ∣ b
⊢ 1 ∣ b
state_after: no goals
Theorem: Cardinal.exists_not_mem_of_length_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: contrapose! h
state_before: α✝ β : Type u
c : Cardinal.{?u.238096}
α : Type u_1
l : List α
h : ↑l.length < #α
⊢ ∃ z, z ∉ l
state_after: α✝ β : Type u
c : Cardinal.{?u.238096}
α : Type u_1
l : List α
h : ∀ (z : α), z ∈ l
⊢ #α ≤ ↑l.length

tactic: calc
  #α = #(Set.univ : Set α) := mk_univ.symm
  _ ≤ #l.toFinset := mk_le_mk_of_subset fun x _ => List.mem_toFinset.mpr (h x)
  _ = l.toFinset.card := Cardinal.mk_coe_finset
  _ ≤ l.length := Cardinal.natCast_le.mpr (List.toFinset_card_le l)
state_before: α✝ β : Type u
c : Cardinal.{?u.238096}
α : Type u_1
l : List α
h : ∀ (z : α), z ∈ l
⊢ #α ≤ ↑l.length
state_after: no goals
Theorem: MeasurableSet.measurableSet_blimsup
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simp only [blimsup_eq_iInf_biSup_of_nat, iSup_eq_iUnion, iInf_eq_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (blimsup s atTop p)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (⋂ i, ⋃ j, ⋃ (_ : p j ∧ i ≤ j), s j)

tactic: exact .iInter fun _ => .iUnion fun m => .iUnion fun hm => h m hm.1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (⋂ i, ⋃ j, ⋃ (_ : p j ∧ i ≤ j), s j)
state_after: no goals
Theorem: Eq.congr_right
File: .lake/packages/batteries/Batteries/Logic.lean

tactic: rw [h]
state_before: α : Sort u_1
x y z : α
h : x = y
⊢ z = x ↔ z = y
state_after: no goals
Theorem: toIocMod_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [sub_eq_add_neg, ← neg_smul, toIocMod_add_zsmul']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp (a - m • p) b = toIocMod hp a b - m • p
state_after: no goals
Theorem: UniformContinuousOn.continuousOn
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformContinuousOn_iff_restrict] at h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuousOn f s
⊢ ContinuousOn f s
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (s.restrict f)
⊢ ContinuousOn f s

tactic: rw [continuousOn_iff_continuous_restrict]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (s.restrict f)
⊢ ContinuousOn f s
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (s.restrict f)
⊢ Continuous (s.restrict f)

tactic: exact h.continuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (s.restrict f)
⊢ Continuous (s.restrict f)
state_after: no goals
Theorem: CategoryTheory.Limits.IsImage.isoExt_hom_m
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.isoExt hF').hom ≫ F'.m = F.m
state_after: no goals
Theorem: Ordinal.bounded_singleton
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine ⟨enum r (succ (typein r x)) (hr.2 _ (typein_lt_type r x)), ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x : α
⊢ Bounded r {x}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x : α
⊢ ∀ b ∈ {x}, r b (enum r (succ (typein r x)) ⋯)

tactic: intro b hb
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x : α
⊢ ∀ b ∈ {x}, r b (enum r (succ (typein r x)) ⋯)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r b (enum r (succ (typein r x)) ⋯)

tactic: rw [mem_singleton_iff.1 hb]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r b (enum r (succ (typein r x)) ⋯)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r x (enum r (succ (typein r x)) ⋯)

tactic: nth_rw 1 [← enum_typein r x]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r x (enum r (succ (typein r x)) ⋯)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r (enum r (typein r x) ⋯) (enum r (succ (typein r x)) ⋯)

tactic: rw [@enum_lt_enum _ r]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ r (enum r (typein r x) ⋯) (enum r (succ (typein r x)) ⋯)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ typein r x < succ (typein r x)

tactic: apply lt_succ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : (type r).IsLimit
x b : α
hb : b ∈ {x}
⊢ typein r x < succ (typein r x)
state_after: no goals
Theorem: IsCompact.eventually_forall_of_forall_eventually
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simp only [nhds_prod_eq, ← eventually_iSup, ← hK.prod_nhdsSet_eq_biSup] at hP
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ y ∈ K, ∀ᶠ (z : X × Y) in 𝓝 (x₀, y), P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ᶠ (z : X × Y) in 𝓝 x₀ ×ˢ 𝓝ˢ K, P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y

tactic: exact hP.curry.mono fun _ h ↦ h.self_of_nhdsSet
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ᶠ (z : X × Y) in 𝓝 x₀ ×ˢ 𝓝ˢ K, P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y
state_after: no goals
Theorem: Set.Iic_diff_Iio
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [diff_eq, compl_Iio, inter_comm, Ici_inter_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iic b \ Iio a = Icc a b
state_after: no goals
Theorem: ENNReal.toNNReal_pos_iff
File: Mathlib/Data/ENNReal/Real.lean

tactic: induction a <;> simp
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 0 < a.toNNReal ↔ 0 < a ∧ a < ⊤
state_after: no goals
Theorem: LieHom.mem_ker
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [ker_coeSubmodule, LinearMap.mem_ker, coe_toLinearMap]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
x : L
⊢ x ∈ ↑f.ker ↔ f x = 0
state_after: no goals
Theorem: eq_mul_of_mul_inv_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * c⁻¹ = b
⊢ a = b * c
state_after: no goals
Theorem: List.span.loop_eq_take_drop
File: Mathlib/Data/List/Basic.lean

tactic: simp [span.loop, takeWhile, dropWhile]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂✝ : List α
p : α → Bool
l₂ : List α
⊢ loop p [] l₂ = (l₂.reverse ++ takeWhile p [], dropWhile p [])
state_after: no goals

tactic: cases hp : p a <;> simp [hp, span.loop, span.loop_eq_take_drop, takeWhile, dropWhile]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂✝ : List α
p : α → Bool
a : α
l l₂ : List α
⊢ loop p (a :: l) l₂ = (l₂.reverse ++ takeWhile p (a :: l), dropWhile p (a :: l))
state_after: no goals
Theorem: Module.End.eigenspace_restrict_le_eigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rintro a ⟨x, hx, rfl⟩
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
⊢ Submodule.map p.subtype (eigenspace (LinearMap.restrict f hfp) μ) ≤ f.eigenspace μ
state_after: case intro.intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : x ∈ ↑(eigenspace (LinearMap.restrict f hfp) μ)
⊢ p.subtype x ∈ f.eigenspace μ

tactic: simp only [SetLike.mem_coe, mem_eigenspace_iff, LinearMap.restrict_apply] at hx ⊢
state_before: case intro.intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : x ∈ ↑(eigenspace (LinearMap.restrict f hfp) μ)
⊢ p.subtype x ∈ f.eigenspace μ
state_after: case intro.intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : ⟨f ↑x, ⋯⟩ = μ • x
⊢ f (p.subtype x) = μ • p.subtype x

tactic: exact congr_arg Subtype.val hx
state_before: case intro.intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : ⟨f ↑x, ⋯⟩ = μ • x
⊢ f (p.subtype x) = μ • p.subtype x
state_after: no goals
Theorem: CochainComplex.prev_nat_zero
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: classical
  refine dif_neg ?_
  push_neg
  intro
  apply Nat.noConfusion
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ (ComplexShape.up ℕ).prev 0 = 0
state_after: no goals

tactic: refine dif_neg ?_
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ (ComplexShape.up ℕ).prev 0 = 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ ¬∃ i, (ComplexShape.up ℕ).Rel i 0

tactic: push_neg
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ ¬∃ i, (ComplexShape.up ℕ).Rel i 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ ∀ (i : ℕ), ¬(ComplexShape.up ℕ).Rel i 0

tactic: intro
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
⊢ ∀ (i : ℕ), ¬(ComplexShape.up ℕ).Rel i 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
i✝ : ℕ
⊢ ¬(ComplexShape.up ℕ).Rel i✝ 0

tactic: apply Nat.noConfusion
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
i✝ : ℕ
⊢ ¬(ComplexShape.up ℕ).Rel i✝ 0
state_after: no goals
Theorem: ENNReal.rpow_rpow_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← rpow_mul, mul_inv_cancel hy, rpow_one]
state_before: y : ℝ
hy : y ≠ 0
x : ℝ≥0∞
⊢ (x ^ y) ^ y⁻¹ = x
state_after: no goals
Theorem: Batteries.RBNode.find?_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [*, find?]
state_before: α : Type u_1
t : RBNode α
cut : α → Ordering
⊢ find? cut t.reverse = find? (fun x => (cut x).swap) t
state_after: case node
α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : find? cut l✝.reverse = find? (fun x => (cut x).swap) l✝
r_ih✝ : find? cut r✝.reverse = find? (fun x => (cut x).swap) r✝
⊢ (match cut v✝ with
    | Ordering.lt => find? (fun x => (cut x).swap) r✝
    | Ordering.gt => find? (fun x => (cut x).swap) l✝
    | Ordering.eq => some v✝) =
    match (cut v✝).swap with
    | Ordering.lt => find? (fun x => (cut x).swap) l✝
    | Ordering.gt => find? (fun x => (cut x).swap) r✝
    | Ordering.eq => some v✝

tactic: cases cut _ <;> simp [Ordering.swap]
state_before: case node
α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : find? cut l✝.reverse = find? (fun x => (cut x).swap) l✝
r_ih✝ : find? cut r✝.reverse = find? (fun x => (cut x).swap) r✝
⊢ (match cut v✝ with
    | Ordering.lt => find? (fun x => (cut x).swap) r✝
    | Ordering.gt => find? (fun x => (cut x).swap) l✝
    | Ordering.eq => some v✝) =
    match (cut v✝).swap with
    | Ordering.lt => find? (fun x => (cut x).swap) l✝
    | Ordering.gt => find? (fun x => (cut x).swap) r✝
    | Ordering.eq => some v✝
state_after: no goals
Theorem: List.prod_range_div
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: rw [← inv_inj, prod_inv, map_map, inv_div, h, prod_range_div']
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup G
n : ℕ
f : ℕ → G
h : ((fun x => x⁻¹) ∘ fun k => f (k + 1) / f k) = fun k => f k / f (k + 1)
⊢ (map (fun k => f (k + 1) / f k) (range n)).prod = f n / f 0
state_after: no goals

tactic: ext
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup G
n : ℕ
f : ℕ → G
⊢ ((fun x => x⁻¹) ∘ fun k => f (k + 1) / f k) = fun k => f k / f (k + 1)
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup G
n : ℕ
f : ℕ → G
x✝ : ℕ
⊢ ((fun x => x⁻¹) ∘ fun k => f (k + 1) / f k) x✝ = f x✝ / f (x✝ + 1)

tactic: apply inv_div
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup G
n : ℕ
f : ℕ → G
x✝ : ℕ
⊢ ((fun x => x⁻¹) ∘ fun k => f (k + 1) / f k) x✝ = f x✝ / f (x✝ + 1)
state_after: no goals