tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_disjiUnion
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: refine' Eq.trans _ (fold_disjiUnion h)
state_before: ι : Type u_1
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : Set.PairwiseDisjoint (↑s) t
⊢ ∏ x in disjiUnion s t h, f x = ∏ i in s, ∏ x in t i, f x

tactic: dsimp [Finset.prod, Multiset.prod, Multiset.fold, Finset.disjUnion, Finset.fold]
state_before: ι : Type u_1
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : Set.PairwiseDisjoint (↑s) t
⊢ ∏ x in disjiUnion s t h, f x =
    fold (fun x x_1 => x * x_1) (fold (fun x x_1 => x * x_1) 1 (fun i => 1) s) (fun x => f x) (disjiUnion s t h)

tactic: congr
state_before: ι : Type u_1
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : Set.PairwiseDisjoint (↑s) t
⊢ Multiset.foldr (fun x x_1 => x * x_1) (_ : ∀ (x y z : β), x * (y * z) = y * (x * z)) 1
      (Multiset.map (fun x => f x) (Multiset.bind s.val fun a => (t a).val)) =
    Multiset.foldr (fun x x_1 => x * x_1) (_ : LeftCommutative fun x x_1 => x * x_1)
      (Multiset.foldr (fun x x_1 => x * x_1) (_ : LeftCommutative fun x x_1 => x * x_1) 1
        (Multiset.map (fun i => 1) s.val))
      (Multiset.map (fun x => f x) (Multiset.bind s.val fun a => (t a).val))

tactic: exact prod_const_one.symm
state_before: case e_b
ι : Type u_1
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : Set.PairwiseDisjoint (↑s) t
⊢ 1 =
    Multiset.foldr (fun x x_1 => x * x_1) (_ : LeftCommutative fun x x_1 => x * x_1) 1 (Multiset.map (fun i => 1) s.val)
Theorem: map_mul_inv
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [map_mul, map_inv]
state_before: α : Type ?u.47943
β : Type ?u.47946
M : Type ?u.47949
N : Type ?u.47952
P : Type ?u.47955
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
a b : G
⊢ ↑f (a * b⁻¹) = ↑f a * (↑f b)⁻¹
Theorem: CategoryTheory.Bicategory.pentagon_inv_hom_hom_hom_hom
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [← cancel_epi ((α_ f g h).hom ▷ i)]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom ≫ (α_ f g (h ≫ i)).hom = (α_ f (g ≫ h) i).hom ≫ f ◁ (α_ g h i).hom
Theorem: ContinuousOn.aestronglyMeasurable_of_isSeparable
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: letI := pseudoMetrizableSpacePseudoMetric α
state_before: α : Type u_1
β : Type u_2
E : Type ?u.1787521
F : Type ?u.1787524
inst✝⁶ : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetrizableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoMetrizableSpace β
f : α → β
s : Set α
μ : MeasureTheory.Measure α
hf : ContinuousOn f s
hs : MeasurableSet s
h's : IsSeparable s
⊢ AEStronglyMeasurable f (Measure.restrict μ s)

tactic: borelize β
state_before: α : Type u_1
β : Type u_2
E : Type ?u.1787521
F : Type ?u.1787524
inst✝⁶ : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetrizableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoMetrizableSpace β
f : α → β
s : Set α
μ : MeasureTheory.Measure α
hf : ContinuousOn f s
hs : MeasurableSet s
h's : IsSeparable s
this : PseudoMetricSpace α := pseudoMetrizableSpacePseudoMetric α
⊢ AEStronglyMeasurable f (Measure.restrict μ s)

tactic: rw [aestronglyMeasurable_iff_aemeasurable_separable]
state_before: α : Type u_1
β : Type u_2
E : Type ?u.1787521
F : Type ?u.1787524
inst✝⁶ : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetrizableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoMetrizableSpace β
f : α → β
s : Set α
μ : MeasureTheory.Measure α
hf : ContinuousOn f s
hs : MeasurableSet s
h's : IsSeparable s
this : PseudoMetricSpace α := pseudoMetrizableSpacePseudoMetric α
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ AEStronglyMeasurable f (Measure.restrict μ s)

tactic: refine' ⟨hf.aemeasurable hs, f '' s, hf.isSeparable_image h's, _⟩
state_before: α : Type u_1
β : Type u_2
E : Type ?u.1787521
F : Type ?u.1787524
inst✝⁶ : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetrizableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoMetrizableSpace β
f : α → β
s : Set α
μ : MeasureTheory.Measure α
hf : ContinuousOn f s
hs : MeasurableSet s
h's : IsSeparable s
this : PseudoMetricSpace α := pseudoMetrizableSpacePseudoMetric α
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ AEMeasurable f ∧ ∃ t, IsSeparable t ∧ ∀ᵐ (x : α) ∂Measure.restrict μ s, f x ∈ t

tactic: exact mem_of_superset (self_mem_ae_restrict hs) (subset_preimage_image _ _)
state_before: α : Type u_1
β : Type u_2
E : Type ?u.1787521
F : Type ?u.1787524
inst✝⁶ : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetrizableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : PseudoMetrizableSpace β
f : α → β
s : Set α
μ : MeasureTheory.Measure α
hf : ContinuousOn f s
hs : MeasurableSet s
h's : IsSeparable s
this : PseudoMetricSpace α := pseudoMetrizableSpacePseudoMetric α
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ s, f x ∈ f '' s
Theorem: MvQPF.wEquiv.abs'
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: revert h
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
h : abs (MvPFunctor.wDest' (P F) x) = abs (MvPFunctor.wDest' (P F) y)
⊢ WEquiv x y

tactic: apply q.P.w_cases _ x
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
⊢ abs (MvPFunctor.wDest' (P F) x) = abs (MvPFunctor.wDest' (P F) y) → WEquiv x y

tactic: intro a₀ f'₀ f₀
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
⊢ ∀ (a : (P F).A) (f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α)
    (f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α),
    abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a f' f)) = abs (MvPFunctor.wDest' (P F) y) →
      WEquiv (MvPFunctor.wMk (P F) a f' f) y

tactic: apply q.P.w_cases _ y
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
⊢ abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a₀ f'₀ f₀)) = abs (MvPFunctor.wDest' (P F) y) →
    WEquiv (MvPFunctor.wMk (P F) a₀ f'₀ f₀) y

tactic: intro a₁ f'₁ f₁
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
⊢ ∀ (a : (P F).A) (f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α)
    (f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α),
    abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a₀ f'₀ f₀)) =
        abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a f' f)) →
      WEquiv (MvPFunctor.wMk (P F) a₀ f'₀ f₀) (MvPFunctor.wMk (P F) a f' f)

tactic: apply WEquiv.abs
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
a₁ : (P F).A
f'₁ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁ ⟹ α
f₁ : PFunctor.B (MvPFunctor.last (P F)) a₁ → MvPFunctor.W (P F) α
⊢ abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a₀ f'₀ f₀)) =
      abs (MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a₁ f'₁ f₁)) →
    WEquiv (MvPFunctor.wMk (P F) a₀ f'₀ f₀) (MvPFunctor.wMk (P F) a₁ f'₁ f₁)
Theorem: Nat.coprime.gcd_mul_right_cancel_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [Nat.mul_comm n k, H.gcd_mul_left_cancel_right n]
state_before: k m n : Nat
H : coprime k m
⊢ gcd m (n * k) = gcd m n
Theorem: Equiv.Set.sumDiffSubset_symm_apply_of_mem
File: Mathlib/Logic/Equiv/Set.lean

tactic: apply (Equiv.Set.sumDiffSubset h).injective
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ ↑(Set.sumDiffSubset h).symm x = Sum.inl { val := ↑x, property := hx }

tactic: simp only [apply_symm_apply, sumDiffSubset_apply_inl]
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ ↑(Set.sumDiffSubset h) (↑(Set.sumDiffSubset h).symm x) =
    ↑(Set.sumDiffSubset h) (Sum.inl { val := ↑x, property := hx })

tactic: exact Subtype.eq rfl
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ x = inclusion h { val := ↑x, property := hx }
Theorem: Polynomial.mem_rootSet
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [mem_rootSet',
  (map_injective _ (NoZeroSMulDivisors.algebraMap_injective T S)).ne_iff' (Polynomial.map_zero _)]
state_before: R : Type u
S✝ : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
p : T[X]
S : Type u_1
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : S
⊢ a ∈ rootSet p S ↔ p ≠ 0 ∧ ↑(aeval a) p = 0
Theorem: ModuleCat.Colimits.cocone_naturality
File: Mathlib/Algebra/Category/ModuleCat/Colimits.lean

tactic: ext
state_before: R : Type u
inst✝¹ : Ring R
J : Type w
inst✝ : Category J
F : J ⥤ ModuleCat R
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ coconeMorphism F j' = coconeMorphism F j

tactic: apply Quot.sound
state_before: case h
R : Type u
inst✝¹ : Ring R
J : Type w
inst✝ : Category J
F : J ⥤ ModuleCat R
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ ↑(F.map f ≫ coconeMorphism F j') x✝ = ↑(coconeMorphism F j) x✝

tactic: apply ModuleCat.Colimits.Relation.map
state_before: case h.a
R : Type u
inst✝¹ : Ring R
J : Type w
inst✝ : Category J
F : J ⥤ ModuleCat R
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ Setoid.r (Prequotient.of j' (↑(F.map f) x✝)) (Prequotient.of j x✝)
Theorem: Compactum.isClosed_cl
File: Mathlib/Topology/Category/Compactum.lean

tactic: rw [isClosed_iff]
state_before: X : Compactum
A : Set X.A
⊢ IsClosed (Compactum.cl A)

tactic: intro F hF
state_before: X : Compactum
A : Set X.A
⊢ ∀ (F : Ultrafilter X.A), Compactum.cl A ∈ F → str X F ∈ Compactum.cl A

tactic: exact cl_cl _ ⟨F, hF, rfl⟩
state_before: X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : Compactum.cl A ∈ F
⊢ str X F ∈ Compactum.cl A
Theorem: Real.exists_rat_pow_btwn_rat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: apply_mod_cast exists_rat_pow_btwn_rat_aux hn x y <;> assumption
state_before: z x✝ y✝ : ℝ
n : ℕ
hn : n ≠ 0
x y : ℚ
h : x < y
hy : 0 < y
⊢ ∃ q, 0 < q ∧ x < q ^ n ∧ q ^ n < y
Theorem: DirectedOn.sSup_inf_eq
File: Mathlib/Order/CompactlyGenerated.lean

tactic: simp_rw [@inf_comm _ _ _ a, h.inf_sSup_eq]
state_before: ι : Sort ?u.94817
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : DirectedOn (fun x x_1 => x ≤ x_1) s
⊢ sSup s ⊓ a = ⨆ (b : α) (_ : b ∈ s), b ⊓ a
Theorem: Set.image2_iInter₂_subset_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_subset_iff, mem_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.254718
ι₂ : Sort ?u.254721
κ : ι → Sort u_5
κ₁ : ι → Sort ?u.254731
κ₂ : ι → Sort ?u.254736
κ' : ι' → Sort ?u.254741
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : (i : ι) → κ i → Set β
⊢ image2 f s (⋂ (i : ι) (j : κ i), t i j) ⊆ ⋂ (i : ι) (j : κ i), image2 f s (t i j)

tactic: exact fun x hx y hy i j => mem_image2_of_mem hx (hy _ _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.254718
ι₂ : Sort ?u.254721
κ : ι → Sort u_5
κ₁ : ι → Sort ?u.254731
κ₂ : ι → Sort ?u.254736
κ' : ι' → Sort ?u.254741
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : (i : ι) → κ i → Set β
⊢ ∀ (x : α),
    x ∈ s → ∀ (y : β), (∀ (i : ι) (i_1 : κ i), y ∈ t i i_1) → ∀ (i : ι) (i_1 : κ i), f x y ∈ image2 f s (t i i_1)
Theorem: AddLECancellable.le_add_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm]
state_before: α : Type u_1
β : Type ?u.23086
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a ≤ a + b - b

tactic: exact hb.le_add_tsub_swap
state_before: α : Type u_1
β : Type ?u.23086
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a ≤ b + a - b
Theorem: MeasureTheory.lintegral_pos_iff_support
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [pos_iff_ne_zero, hf, Filter.EventuallyEq, ae_iff, Function.support]
state_before: α : Type u_1
β : Type ?u.973547
γ : Type ?u.973550
δ : Type ?u.973553
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (0 < ∫⁻ (a : α), f a ∂μ) ↔ 0 < ↑↑μ (support f)
Theorem: ProbabilityTheory.kernel.set_lintegral_const
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.const_apply]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.980848
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
f : β → ℝ≥0∞
μ : MeasureTheory.Measure β
a : α
s : Set β
⊢ (∫⁻ (x : β) in s, f x ∂↑(const α μ) a) = ∫⁻ (x : β) in s, f x ∂μ
Theorem: Nat.bit_ne_zero
File: Mathlib/Data/Nat/Bits.lean

tactic: cases b <;> [exact Nat.bit0_ne_zero h; exact Nat.bit1_ne_zero _]
state_before: n✝ : ℕ
b : Bool
n : ℕ
h : n ≠ 0
⊢ bit b n ≠ 0
Theorem: List.dropSlice_eq_dropSliceTR
File: Std/Data/List/Basic.lean

tactic: funext α n m l
state_before: ⊢ @dropSlice = @dropSliceTR

tactic: simp [dropSliceTR]
state_before: case h.h.h.h
α : Type u_1
n m : Nat
l : List α
⊢ dropSlice n m l = dropSliceTR n m l

tactic: split
state_before: case h.h.h.h
α : Type u_1
n m : Nat
l : List α
⊢ dropSlice n m l =
    match m with
    | 0 => l
    | succ m => dropSliceTR.go l m l n #[]

tactic: { rw [dropSlice_zero₂] }
state_before: case h.h.h.h.h_1
α : Type u_1
n : Nat
l : List α
m✝ : Nat
⊢ dropSlice n 0 l = l

case h.h.h.h.h_2
α : Type u_1
n : Nat
l : List α
m✝¹ m✝ : Nat
⊢ dropSlice n (succ m✝) l = dropSliceTR.go l m✝ l n #[]

tactic: rename_i m
state_before: case h.h.h.h.h_2
α : Type u_1
n : Nat
l : List α
m✝¹ m✝ : Nat
⊢ dropSlice n (succ m✝) l = dropSliceTR.go l m✝ l n #[]

tactic: let rec go (acc) : ∀ xs n, l = acc.data ++ xs →
  dropSliceTR.go l m xs n acc = acc.data ++ xs.dropSlice n (m+1)
| [],    n
| _::xs, 0 => fun h => by simp [dropSliceTR.go, dropSlice, h]
| x::xs, n+1 => by simp [dropSliceTR.go, dropSlice]; intro h; rw [go _ xs]; {simp}; simp [h]
state_before: case h.h.h.h.h_2
α : Type u_1
n : Nat
l : List α
m✝ m : Nat
⊢ dropSlice n (succ m) l = dropSliceTR.go l m l n #[]

tactic: exact (go #[] _ _ rfl).symm
state_before: case h.h.h.h.h_2
α : Type u_1
n : Nat
l : List α
m✝ m : Nat
⊢ dropSlice n (succ m) l = dropSliceTR.go l m l n #[]

tactic: simp [dropSliceTR.go, dropSlice, h]
state_before: α : Type u_1
n : Nat
l : List α
m✝ m : Nat
acc : Array α
head✝ : α
xs : List α
h : l = acc.data ++ head✝ :: xs
⊢ dropSliceTR.go l m (head✝ :: xs) 0 acc = acc.data ++ dropSlice 0 (m + 1) (head✝ :: xs)

tactic: simp [dropSliceTR.go, dropSlice]
state_before: α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
⊢ l = acc.data ++ x :: xs → dropSliceTR.go l m (x :: xs) (n + 1) acc = acc.data ++ dropSlice (n + 1) (m + 1) (x :: xs)

tactic: intro h
state_before: α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
⊢ l = acc.data ++ x :: xs → dropSliceTR.go l m xs n (Array.push acc x) = acc.data ++ x :: dropSlice n (m + 1) xs

tactic: rw [go _ xs]
state_before: α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ dropSliceTR.go l m xs n (Array.push acc x) = acc.data ++ x :: dropSlice n (m + 1) xs

tactic: {simp}
state_before: α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ (Array.push acc x).data ++ dropSlice n (m + 1) xs = acc.data ++ x :: dropSlice n (m + 1) xs

case a
α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs

tactic: simp [h]
state_before: case a
α : Type u_1
n✝ : Nat
l : List α
m✝ m : Nat
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : ↑Fin.castSucc j < i
⊢ δ X (Fin.succ i) ≫ σ X (↑Fin.castSucc j) = σ X j ≫ δ X i

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_σ_of_gt H]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : ↑Fin.castSucc j < i
⊢ X.map (SimplexCategory.δ (Fin.succ i)) ≫ X.map (SimplexCategory.σ (↑Fin.castSucc j)) =
    X.map (SimplexCategory.σ j) ≫ X.map (SimplexCategory.δ i)
Theorem: CategoryTheory.exact_of_image_eq_kernel
File: Mathlib/Algebra/Homology/Exact.lean

tactic: haveI := imageToKernel_isIso_of_image_eq_kernel f g p
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ Epi (imageToKernel f g (_ : f ≫ g = 0))

tactic: infer_instance
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
this : IsIso (imageToKernel f g (_ : f ≫ g = 0))
⊢ Epi (imageToKernel f g (_ : f ≫ g = 0))
Theorem: Filter.inter_eventuallyEq_left
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [eventuallyEq_set, mem_inter_iff, and_iff_left_iff_imp]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.190339
ι : Sort x
s t : Set α
l : Filter α
⊢ s ∩ t =ᶠ[l] s ↔ ∀ᶠ (x : α) in l, x ∈ s → x ∈ t
Theorem: StrictConvexSpace.ofNormComboLtOne
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: refine'
  StrictConvexSpace.ofStrictConvexClosedUnitBall ℝ
    ((convex_closedBall _ _).strictConvex' fun x hx y hy hne => _)
state_before: 𝕜 : Type ?u.12558
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, a + b = 1 ∧ ‖a • x + b • y‖ < 1
⊢ StrictConvexSpace ℝ E

tactic: rw [interior_closedBall (0 : E) one_ne_zero, closedBall_diff_ball,
  mem_sphere_zero_iff_norm] at hx hy
state_before: 𝕜 : Type ?u.12558
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, a + b = 1 ∧ ‖a • x + b • y‖ < 1
x : E
hx : x ∈ closedBall 0 1 \ interior (closedBall 0 1)
y : E
hy : y ∈ closedBall 0 1 \ interior (closedBall 0 1)
hne : x ≠ y
⊢ (fun x y => ∃ c, ↑(AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)) x y

tactic: rcases h x y hx hy hne with ⟨a, b, hab, hlt⟩
state_before: 𝕜 : Type ?u.12558
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, a + b = 1 ∧ ‖a • x + b • y‖ < 1
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ∃ c, ↑(AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)

tactic: use b
state_before: case intro.intro.intro
𝕜 : Type ?u.12558
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, a + b = 1 ∧ ‖a • x + b • y‖ < 1
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
hne : x ≠ y
a b : ℝ
hab : a + b = 1
hlt : ‖a • x + b • y‖ < 1
⊢ ∃ c, ↑(AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)

tactic: rwa [AffineMap.lineMap_apply_module, interior_closedBall (0 : E) one_ne_zero, mem_ball_zero_iff,
  sub_eq_iff_eq_add.2 hab.symm]
state_before: case intro.intro.intro
𝕜 : Type ?u.12558
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, a + b = 1 ∧ ‖a • x + b • y‖ < 1
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
hne : x ≠ y
a b : ℝ
hab : a + b = 1
hlt : ‖a • x + b • y‖ < 1
⊢ ↑(AffineMap.lineMap x y) b ∈ interior (closedBall 0 1)
Theorem: Dfinsupp.erase_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: rw [← filter_ne_eq_erase, filter_single, ite_not]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ j i : ι
x : β i
⊢ erase j (single i x) = if i = j then 0 else single i x
Theorem: Multiset.count_erase_of_ne
File: Mathlib/Data/Multiset/Basic.lean

tactic: convert List.count_erase_of_ne ab l <;> rw [←coe_count] <;> simp
state_before: α : Type u_1
β : Type ?u.376488
γ : Type ?u.376491
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
s : Multiset α
l : List α
⊢ count a (erase (Quotient.mk (isSetoid α) l) b) = count a (Quotient.mk (isSetoid α) l)
Theorem: interval_average_symm
File: Mathlib/MeasureTheory/Integral/IntervalAverage.lean

tactic: rw [set_average_eq, set_average_eq, uIoc_comm]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
a b : ℝ
⊢ (⨍ (x : ℝ) in Ι a b, f x) = ⨍ (x : ℝ) in Ι b a, f x
Theorem: Matrix.cons_vecMul_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Semiring α
x : α
v : Fin n → α
w : o' → α
B : Fin n → o' → α
⊢ vecMul (vecCons x v) (↑of (vecCons w B)) = x • w + vecMul v (↑of B)
Theorem: Polynomial.content_zero
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← C_0, content_C, normalize_zero]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
⊢ content 0 = 0
Theorem: Bool.decide_not
File: Mathlib/Data/Bool/Basic.lean

tactic: by_cases p <;> simp [*]
state_before: p : Prop
inst✝ : Decidable p
⊢ (decide ¬p) = !decide p
Theorem: Mathlib.Tactic.Abel.term_atom
File: Mathlib/Tactic/Abel.lean

tactic: simp [term]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
x : α
⊢ x = term 1 x 0
Theorem: Equiv.Perm.disjoint_refl_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine' ⟨fun h => _, fun h => h.symm ▸ disjoint_one_left 1⟩
state_before: α : Type u_1
f g h : Perm α
⊢ Disjoint f f ↔ f = 1

tactic: ext x
state_before: α : Type u_1
f g h✝ : Perm α
h : Disjoint f f
⊢ f = 1

tactic: cases' h x with hx hx <;> simp [hx]
state_before: case H
α : Type u_1
f g h✝ : Perm α
h : Disjoint f f
x : α
⊢ ↑f x = ↑1 x
Theorem: Part.toFinset_none
File: Mathlib/Data/Finset/PImage.lean

tactic: simp [toFinset]
state_before: α : Type u_1
β : Type ?u.311
inst✝ : Decidable none.Dom
⊢ toFinset none = ∅