tasksource/leandojo huggingface dataset:
Theorem: Set.inter_indicator_mul
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: rw [← Set.indicator_indicator]
state_before: α : Type u_1
β : Type ?u.124894
ι : Type ?u.124897
M : Type u_2
N : Type ?u.124903
inst✝ : MulZeroClass M
s t : Set α
f✝ g✝ : α → M
a : α
t1 t2 : Set α
f g : α → M
x : α
⊢ indicator (t1 ∩ t2) (fun x => f x * g x) x = indicator t1 f x * indicator t2 g x

tactic: simp_rw [indicator]
state_before: α : Type u_1
β : Type ?u.124894
ι : Type ?u.124897
M : Type u_2
N : Type ?u.124903
inst✝ : MulZeroClass M
s t : Set α
f✝ g✝ : α → M
a : α
t1 t2 : Set α
f g : α → M
x : α
⊢ indicator t1 (indicator t2 fun x => f x * g x) x = indicator t1 f x * indicator t2 g x

tactic: split_ifs <;> simp
state_before: α : Type u_1
β : Type ?u.124894
ι : Type ?u.124897
M : Type u_2
N : Type ?u.124903
inst✝ : MulZeroClass M
s t : Set α
f✝ g✝ : α → M
a : α
t1 t2 : Set α
f g : α → M
x : α
⊢ (if x ∈ t1 then if x ∈ t2 then f x * g x else 0 else 0) = (if x ∈ t1 then f x else 0) * if x ∈ t2 then g x else 0
Theorem: Subgroup.closure_mul_image_eq_top'
File: Mathlib/GroupTheory/Schreier.lean

tactic: rw [Finset.coe_image, Finset.coe_mul]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
R✝ S✝ : Set G
inst✝ : DecidableEq G
R S : Finset G
hR : ↑R ∈ rightTransversals ↑H
hR1 : 1 ∈ R
hS : closure ↑S = ⊤
⊢ closure
      ↑(Finset.image (fun g => { val := g * (↑(toFun hR g))⁻¹, property := (_ : g * (↑(toFun hR g))⁻¹ ∈ H) }) (R * S)) =
    ⊤

tactic: exact closure_mul_image_eq_top hR hR1 hS
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
R✝ S✝ : Set G
inst✝ : DecidableEq G
R S : Finset G
hR : ↑R ∈ rightTransversals ↑H
hR1 : 1 ∈ R
hS : closure ↑S = ⊤
⊢ closure ((fun g => { val := g * (↑(toFun hR g))⁻¹, property := (_ : g * (↑(toFun hR g))⁻¹ ∈ H) }) '' (↑R * ↑S)) = ⊤
Theorem: one_leftCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [leftCoset]
state_before: α : Type u_1
inst✝ : Monoid α
s : Set α
⊢ ∀ (x : α), x ∈ 1 *l s ↔ x ∈ s
Theorem: CategoryTheory.Limits.PreservesPullback.iso_hom_snd
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: simp [PreservesPullback.iso]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
inst✝² : PreservesLimit (cospan f g) G
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
⊢ (iso G f g).hom ≫ pullback.snd = G.map pullback.snd
Theorem: TopologicalSpace.Opens.ne_bot_iff_nonempty
File: Mathlib/Topology/Sets/Opens.lean

tactic: rw [Ne.def, ← not_nonempty_iff_eq_bot, not_not]
state_before: ι : Type ?u.28417
α : Type u_1
β : Type ?u.28423
γ : Type ?u.28426
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U : Opens α
⊢ U ≠ ⊥ ↔ Set.Nonempty ↑U
Theorem: MeasureTheory.ae_dirac_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext s
state_before: α : Type u_1
β : Type ?u.600866
γ : Type ?u.600869
δ : Type ?u.600872
ι : Type ?u.600875
R : Type ?u.600878
R' : Type ?u.600881
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
⊢ ae (dirac a) = pure a

tactic: simp [mem_ae_iff, imp_false]
state_before: case a
α : Type u_1
β : Type ?u.600866
γ : Type ?u.600869
δ : Type ?u.600872
ι : Type ?u.600875
R : Type ?u.600878
R' : Type ?u.600881
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
⊢ s ∈ ae (dirac a) ↔ s ∈ pure a
Theorem: SimpleGraph.Walk.isPath_iff_eq_nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp [IsPath.nil]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : Walk G u u
⊢ IsPath p ↔ p = nil
Theorem: MeasureTheory.OuterMeasure.exists_mem_forall_mem_nhds_within_pos
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: contrapose! hs
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
hs : ↑m s ≠ 0
⊢ ∃ x, x ∈ s ∧ ∀ (t : Set α), t ∈ 𝓝[s] x → 0 < ↑m t

tactic: simp only [nonpos_iff_eq_zero, ← exists_prop] at hs
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
hs : ∀ (x : α), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ↑m t ≤ 0
⊢ ↑m s = 0

tactic: apply m.null_of_locally_null s
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
hs : ∀ (x : α), x ∈ s → ∃ t _h, ↑m t = 0
⊢ ↑m s = 0

tactic: intro x hx
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
hs : ∀ (x : α), x ∈ s → ∃ t _h, ↑m t = 0
⊢ ∀ (x : α), x ∈ s → ∃ u, u ∈ 𝓝[s] x ∧ ↑m u = 0

tactic: specialize hs x hx
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
hs : ∀ (x : α), x ∈ s → ∃ t _h, ↑m t = 0
x : α
hx : x ∈ s
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ↑m u = 0

tactic: exact Iff.mp bex_def hs
state_before: α : Type u_1
β : Type ?u.10003
R : Type ?u.10006
R' : Type ?u.10009
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝¹ : TopologicalSpace α
inst✝ : SecondCountableTopology α
m : OuterMeasure α
s : Set α
x : α
hx : x ∈ s
hs : ∃ t _h, ↑m t = 0
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ↑m u = 0
Theorem: div_le_div_iff'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simpa only [div_eq_mul_inv] using mul_inv_le_mul_inv_iff'
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ c / d ↔ a * d ≤ c * b
Theorem: CategoryTheory.Limits.kernelSubobjectMap_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁴ : Category C
X Y Z : C
inst✝³ : HasZeroMorphisms C
f : X ⟶ Y
inst✝² : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝¹ : HasKernel f'
X'' Y'' : C
f'' : X'' ⟶ Y''
inst✝ : HasKernel f''
sq : Arrow.mk f ⟶ Arrow.mk f'
sq' : Arrow.mk f' ⟶ Arrow.mk f''
⊢ kernelSubobjectMap (sq ≫ sq') = kernelSubobjectMap sq ≫ kernelSubobjectMap sq'
Theorem: IntermediateField.Lifts.exists_max_three
File: Mathlib/FieldTheory/Adjoin.lean

tactic: obtain ⟨v, hv, hxv, hyv⟩ := Lifts.exists_max_two hc hx hy
state_before: F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y z : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
hz : z ∈ insert ⊥ c
⊢ ∃ w, w ∈ insert ⊥ c ∧ x ≤ w ∧ y ≤ w ∧ z ≤ w

tactic: obtain ⟨w, hw, hzw, hvw⟩ := Lifts.exists_max_two hc hz hv
state_before: case intro.intro.intro
F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y z : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
hz : z ∈ insert ⊥ c
v : Lifts F E K
hv : v ∈ insert ⊥ c
hxv : x ≤ v
hyv : y ≤ v
⊢ ∃ w, w ∈ insert ⊥ c ∧ x ≤ w ∧ y ≤ w ∧ z ≤ w

tactic: exact ⟨w, hw, le_trans hxv hvw, le_trans hyv hvw, hzw⟩
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y z : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
hz : z ∈ insert ⊥ c
v : Lifts F E K
hv : v ∈ insert ⊥ c
hxv : x ≤ v
hyv : y ≤ v
w : Lifts F E K
hw : w ∈ insert ⊥ c
hzw : z ≤ w
hvw : v ≤ w
⊢ ∃ w, w ∈ insert ⊥ c ∧ x ≤ w ∧ y ≤ w ∧ z ≤ w
Theorem: IsRightRegular.pow
File: Mathlib/Algebra/Regular/Pow.lean

tactic: rw [IsRightRegular, ← mul_right_iterate]
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
rra : IsRightRegular a
⊢ IsRightRegular (a ^ n)

tactic: exact rra.iterate n
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
rra : IsRightRegular a
⊢ Function.Injective ((fun x => x * a)^[n])
Theorem: Equiv.self_trans_symm
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ ∀ (x : α), ↑(e.trans e.symm) x = ↑(Equiv.refl α) x
Theorem: Ordinal.zero_sub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Ordinal.le_zero]
state_before: α : Type ?u.131620
β : Type ?u.131623
γ : Type ?u.131626
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ 0 - a = 0

tactic: apply sub_le_self
state_before: α : Type ?u.131620
β : Type ?u.131623
γ : Type ?u.131626
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ 0 - a ≤ 0
Theorem: deriv.lhopital_zero_left_on_Ioo
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: have hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x := fun x hx =>
  (hdf x hx).differentiableAt (Ioo_mem_nhds hx.1 hx.2)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → deriv g x ≠ 0
hfb : Tendsto f (𝓝[Iio b] b) (𝓝 0)
hgb : Tendsto g (𝓝[Iio b] b) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => f x / g x) (𝓝[Iio b] b) l

tactic: have hdg : ∀ x ∈ Ioo a b, DifferentiableAt ℝ g x := fun x hx =>
  by_contradiction fun h => hg' x hx (deriv_zero_of_not_differentiableAt h)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → deriv g x ≠ 0
hfb : Tendsto f (𝓝[Iio b] b) (𝓝 0)
hgb : Tendsto g (𝓝[Iio b] b) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Iio b] b) l
hdf : ∀ (x : ℝ), x ∈ Ioo a b → DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) (𝓝[Iio b] b) l

tactic: exact HasDerivAt.lhopital_zero_left_on_Ioo hab (fun x hx => (hdf x hx).hasDerivAt)
  (fun x hx => (hdg x hx).hasDerivAt) hg' hfb hgb hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → deriv g x ≠ 0
hfb : Tendsto f (𝓝[Iio b] b) (𝓝 0)
hgb : Tendsto g (𝓝[Iio b] b) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Iio b] b) l
hdf : ∀ (x : ℝ), x ∈ Ioo a b → DifferentiableAt ℝ f x
hdg : ∀ (x : ℝ), x ∈ Ioo a b → DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) (𝓝[Iio b] b) l
Theorem: PGame.equiv_of_eq
File: Mathlib/SetTheory/Game/PGame.lean

tactic: subst h
state_before: x y : PGame
h : x = y
⊢ x ≈ y

tactic: rfl
state_before: x : PGame
⊢ x ≈ x
Theorem: SimpleGraph.dotProduct_adjMatrix
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [neighborFinset_eq_filter, dotProduct, sum_filter, Finset.sum_apply]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.37315
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype V
inst✝ : NonAssocSemiring α
v : V
vec : V → α
⊢ vec ⬝ᵥ adjMatrix α G v = ∑ u in neighborFinset G v, vec u
Theorem: Polynomial.lifts_and_natDegree_eq_and_monic
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: cases' subsingleton_or_nontrivial S with hR hR
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : Monic p
⊢ ∃ q, map f q = p ∧ natDegree q = natDegree p ∧ Monic q

tactic: obtain ⟨p', h₁, h₂, h₃⟩ := lifts_and_degree_eq_and_monic hlifts hp
state_before: case inr
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : Monic p
hR : Nontrivial S
⊢ ∃ q, map f q = p ∧ natDegree q = natDegree p ∧ Monic q

tactic: exact ⟨p', h₁, natDegree_eq_of_degree_eq h₂, h₃⟩
state_before: case inr.intro.intro.intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : Monic p
hR : Nontrivial S
p' : R[X]
h₁ : map f p' = p
h₂ : degree p' = degree p
h₃ : Monic p'
⊢ ∃ q, map f q = p ∧ natDegree q = natDegree p ∧ Monic q

tactic: obtain rfl : p = 1 := Subsingleton.elim _ _
state_before: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : Monic p
hR : Subsingleton S
⊢ ∃ q, map f q = p ∧ natDegree q = natDegree p ∧ Monic q

tactic: refine' ⟨1, Subsingleton.elim _ _, by simp, by simp⟩
state_before: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ ∃ q, map f q = 1 ∧ natDegree q = natDegree 1 ∧ Monic q

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ natDegree 1 = natDegree 1

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ Monic 1
Theorem: CategoryTheory.tensorRightHomEquiv_tensor_id_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorRightHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ ↑(tensorRightHomEquiv Y X Xᘁ (𝟙_ C)) ((f ⊗ 𝟙 X) ≫ ε_ X Xᘁ) = f ≫ (λ_ Xᘁ).inv

tactic: rw [comp_tensor_id]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ (ρ_ Y).inv ≫ (𝟙 Y ⊗ η_ X Xᘁ) ≫ (α_ Y X Xᘁ).inv ≫ ((f ⊗ 𝟙 X) ≫ ε_ X Xᘁ ⊗ 𝟙 Xᘁ) = f ≫ (λ_ Xᘁ).inv

tactic: slice_lhs 3 4 => rw [← associator_inv_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ (ρ_ Y).inv ≫ (𝟙 Y ⊗ η_ X Xᘁ) ≫ (α_ Y X Xᘁ).inv ≫ ((f ⊗ 𝟙 X) ⊗ 𝟙 Xᘁ) ≫ (ε_ X Xᘁ ⊗ 𝟙 Xᘁ) = f ≫ (λ_ Xᘁ).inv

tactic: slice_lhs 2 3 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ (ρ_ Y).inv ≫ (𝟙 Y ⊗ η_ X Xᘁ) ≫ ((f ⊗ 𝟙 X ⊗ 𝟙 Xᘁ) ≫ (α_ Xᘁ X Xᘁ).inv) ≫ (ε_ X Xᘁ ⊗ 𝟙 Xᘁ) = f ≫ (λ_ Xᘁ).inv

tactic: slice_lhs 3 5 => rw [coevaluation_evaluation]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ (ρ_ Y).inv ≫ (((f ⊗ 𝟙 tensorUnit') ≫ (𝟙 Xᘁ ⊗ η_ X Xᘁ)) ≫ (α_ Xᘁ X Xᘁ).inv) ≫ (ε_ X Xᘁ ⊗ 𝟙 Xᘁ) = f ≫ (λ_ Xᘁ).inv

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y : C
inst✝ : HasRightDual X
f : Y ⟶ Xᘁ
⊢ (ρ_ Y).inv ≫ (f ⊗ 𝟙 tensorUnit') ≫ (ρ_ Xᘁ).hom ≫ (λ_ Xᘁ).inv = f ≫ (λ_ Xᘁ).inv
Theorem: Finset.filter_cons
File: Mathlib/Data/Finset/Basic.lean

tactic: split_ifs
state_before: α : Type ?u.367165
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
⊢ _root_.Disjoint (if p a then {a} else ∅) (filter p s)

tactic: rw [disjoint_singleton_left]
state_before: case inl
α : Type ?u.367165
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
h✝ : p a
⊢ _root_.Disjoint {a} (filter p s)

tactic: exact mem_filter.not.mpr <| mt And.left ha
state_before: case inl
α : Type ?u.367165
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
h✝ : p a
⊢ ¬a ∈ filter p s

tactic: exact disjoint_empty_left _
state_before: case inr
α : Type ?u.367165
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
h✝ : ¬p a
⊢ _root_.Disjoint ∅ (filter p s)

tactic: split_ifs with h
state_before: α : Type u_1
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
⊢ filter p (cons a s ha) =
    disjUnion (if p a then {a} else ∅) (filter p s) (_ : _root_.Disjoint (if p a then {a} else ∅) (filter p s))

tactic: rw [filter_cons_of_pos _ _ _ ha h, singleton_disjUnion]
state_before: case inl
α : Type u_1
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
h : p a
⊢ filter p (cons a s ha) = disjUnion {a} (filter p s) (_ : _root_.Disjoint {a} (filter p s))

tactic: rw [filter_cons_of_neg _ _ _ ha h, empty_disjUnion]
state_before: case inr
α : Type u_1
β : Type ?u.367168
γ : Type ?u.367171
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
s : Finset α
ha : ¬a ∈ s
h : ¬p a
⊢ filter p (cons a s ha) = disjUnion ∅ (filter p s) (_ : _root_.Disjoint ∅ (filter p s))
Theorem: invOf_two_add_invOf_two
File: Mathlib/Algebra/Invertible.lean

tactic: rw [← two_mul, mul_invOf_self]
state_before: α : Type u
inst✝¹ : NonAssocSemiring α
inst✝ : Invertible 2
⊢ ⅟2 + ⅟2 = 1
Theorem: Traversable.naturality_pf
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
η : ApplicativeTransformation F G
f : α → F β
⊢ traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) =
    (fun {α} => ApplicativeTransformation.app η α) ∘ traverse f

tactic: rw [comp_apply, naturality]
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
η : ApplicativeTransformation F G
f : α → F β
x✝ : t α
⊢ traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x✝ =
    ((fun {α} => ApplicativeTransformation.app η α) ∘ traverse f) x✝
Theorem: Fin.add_one_pos
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
i : Fin (n + 1)
h : i < last n
⊢ 0 < i + 1

tactic: exact absurd h (Nat.not_lt_zero _)
state_before: case zero
m : ℕ
i : Fin (zero + 1)
h : i < last zero
⊢ 0 < i + 1

tactic: rw [lt_iff_val_lt_val, val_last, ← add_lt_add_iff_right 1] at h
state_before: case succ
m n✝ : ℕ
i : Fin (Nat.succ n✝ + 1)
h : i < last (Nat.succ n✝)
⊢ 0 < i + 1

tactic: rw [lt_iff_val_lt_val, val_add, val_zero, val_one, Nat.mod_eq_of_lt h]
state_before: case succ
m n✝ : ℕ
i : Fin (Nat.succ n✝ + 1)
h✝ : ↑i < Nat.succ n✝
h : ↑i + 1 < Nat.succ n✝ + 1
⊢ 0 < i + 1

tactic: exact Nat.zero_lt_succ _
state_before: case succ
m n✝ : ℕ
i : Fin (Nat.succ n✝ + 1)
h✝ : ↑i < Nat.succ n✝
h : ↑i + 1 < Nat.succ n✝ + 1
⊢ 0 < ↑i + 1
Theorem: Module.DualBases.lc_coeffs
File: Mathlib/LinearAlgebra/Dual.lean

tactic: refine' eq_of_sub_eq_zero (h.Total _)
state_before: R : Type u_2
M : Type u_1
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
m : M
⊢ lc e (coeffs h m) = m

tactic: intro i
state_before: R : Type u_2
M : Type u_1
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
m : M
⊢ ∀ (i : ι), ↑(ε i) (lc e (coeffs h m) - m) = 0

tactic: simp [LinearMap.map_sub, h.dual_lc, sub_eq_zero]
state_before: R : Type u_2
M : Type u_1
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
m : M
i : ι
⊢ ↑(ε i) (lc e (coeffs h m) - m) = 0
Theorem: List.rotate_eq_drop_append_take
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ length l → rotate l n = drop n l ++ take n l

tactic: exact rotate'_eq_drop_append_take
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ length l → rotate' l n = drop n l ++ take n l
Theorem: List.sorted_mergeSort
File: Mathlib/Data/List/Sort.lean

tactic: simp [mergeSort]
state_before: α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
⊢ Sorted r (mergeSort r [])

tactic: simp [mergeSort]
state_before: α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a : α
⊢ Sorted r (mergeSort r [a])

tactic: cases' e : split (a :: b :: l) with l₁ l₂
state_before: α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
⊢ Sorted r (mergeSort r (a :: b :: l))

tactic: cases' length_split_lt e with h₁ h₂
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : split (a :: b :: l) = (l₁, l₂)
⊢ Sorted r (mergeSort r (a :: b :: l))

tactic: rw [mergeSort_cons_cons r e]
state_before: case mk.intro
α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : split (a :: b :: l) = (l₁, l₂)
h₁ : length l₁ < length (a :: b :: l)
h₂ : length l₂ < length (a :: b :: l)
⊢ Sorted r (mergeSort r (a :: b :: l))

tactic: exact (sorted_mergeSort l₁).merge (sorted_mergeSort l₂)
state_before: case mk.intro
α : Type uu
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : split (a :: b :: l) = (l₁, l₂)
h₁ : length l₁ < length (a :: b :: l)
h₂ : length l₂ < length (a :: b :: l)
⊢ Sorted r (merge r (mergeSort r l₁) (mergeSort r l₂))
Theorem: PowerSeries.coeff_sin_bit1
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: rw [sin, coeff_mk, if_neg n.not_even_bit1, Nat.bit1_div_two, ← mul_one_div, map_mul, map_pow,
  map_neg, map_one, coeff_exp]
state_before: A : Type u_1
A' : Type ?u.354098
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ ↑(coeff A (bit1 n)) (sin A) = (-1) ^ n * ↑(coeff A (bit1 n)) (exp A)
Theorem: List.join_filter_isEmpty_eq_false
File: Mathlib/Data/List/Join.lean

tactic: simp [join_filter_isEmpty_eq_false (L := L), isEmpty_iff_eq_nil]
state_before: α : Type u_1
β : Type ?u.1507
inst✝ : DecidablePred fun l => isEmpty l = false
L : List (List α)
⊢ join (filter (fun l => decide (isEmpty l = false)) ([] :: L)) = join ([] :: L)

tactic: have cons_not_empty : isEmpty (a :: l) = false := rfl
state_before: α : Type u_1
β : Type ?u.1507
inst✝ : DecidablePred fun l => isEmpty l = false
a : α
l : List α
L : List (List α)
⊢ join (filter (fun l => decide (isEmpty l = false)) ((a :: l) :: L)) = join ((a :: l) :: L)

tactic: simp [join_filter_isEmpty_eq_false (L := L), cons_not_empty]
state_before: α : Type u_1
β : Type ?u.1507
inst✝ : DecidablePred fun l => isEmpty l = false
a : α
l : List α
L : List (List α)
cons_not_empty : isEmpty (a :: l) = false
⊢ join (filter (fun l => decide (isEmpty l = false)) ((a :: l) :: L)) = join ((a :: l) :: L)