tasksource/leandojo huggingface dataset:
Theorem: Subspace.dualRestrict_comp_dualLift
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext (φ x)
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
⊢ comp (dualRestrict W) (dualLift W) = 1

tactic: simp
state_before: case h.h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
φ : Module.Dual K { x // x ∈ W }
x : { x // x ∈ W }
⊢ ↑(↑(comp (dualRestrict W) (dualLift W)) φ) x = ↑(↑1 φ) x
Theorem: Vector.get_set_same
File: Mathlib/Data/Vector/Basic.lean

tactic: cases v
state_before: n : ℕ
α : Type u_1
β : Type ?u.57781
γ : Type ?u.57784
v : Vector α n
i : Fin n
a : α
⊢ get (set v i a) i = a

tactic: cases i
state_before: case mk
n : ℕ
α : Type u_1
β : Type ?u.57781
γ : Type ?u.57784
i : Fin n
a : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ get (set { val := val✝, property := property✝ } i a) i = a

tactic: simp [Vector.set, get_eq_get]
state_before: case mk.mk
n : ℕ
α : Type u_1
β : Type ?u.57781
γ : Type ?u.57784
a : α
val✝¹ : List α
property✝ : List.length val✝¹ = n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ get (set { val := val✝¹, property := property✝ } { val := val✝, isLt := isLt✝ } a) { val := val✝, isLt := isLt✝ } = a

tactic: dsimp
state_before: case mk.mk
n : ℕ
α : Type u_1
β : Type ?u.57781
γ : Type ?u.57784
a : α
val✝¹ : List α
property✝ : List.length val✝¹ = n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ List.get (List.set val✝¹ val✝ a)
      (↑(Fin.cast
            (_ :
              n =
                List.length
                  (toList
                    { val := List.set val✝¹ val✝ a,
                      property :=
                        (_ :
                          List.length
                              (List.set (↑{ val := val✝¹, property := property✝ }) (↑{ val := val✝, isLt := isLt✝ })
                                a) =
                            n) })))
        { val := val✝, isLt := isLt✝ }) =
    a

tactic: exact List.get_set_eq _ _ _ _
state_before: case mk.mk
n : ℕ
α : Type u_1
β : Type ?u.57781
γ : Type ?u.57784
a : α
val✝¹ : List α
property✝ : List.length val✝¹ = n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ List.get (List.set val✝¹ val✝ a)
      (↑(Fin.cast (_ : n = List.length (List.set val✝¹ val✝ a))) { val := val✝, isLt := isLt✝ }) =
    a
Theorem: t0Space_iff_not_inseparable
File: Mathlib/Topology/Separation.lean

tactic: simp only [t0Space_iff_inseparable, Ne.def, not_imp_not]
state_before: α✝ : Type u
β : Type v
inst✝¹ : TopologicalSpace α✝
α : Type u
inst✝ : TopologicalSpace α
⊢ T0Space α ↔ ∀ (x y : α), x ≠ y → ¬Inseparable x y
Theorem: MeasureTheory.SimpleFunc.tendsto_approxOn_range_Lp
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp
state_before: α : Type ?u.804606
β : Type ?u.804609
ι : Type ?u.804612
E : Type ?u.804615
F : Type ?u.804618
𝕜 : Type ?u.804621
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : BorelSpace E
f : β → E
hp : Fact (1 ≤ p)
hp_ne_top : p ≠ ⊤
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Memℒp f p
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}

tactic: simpa only [Lp.tendsto_Lp_iff_tendsto_ℒp''] using
  tendsto_approxOn_range_Lp_snorm hp_ne_top fmeas hf.2
state_before: α : Type ?u.804606
β : Type u_2
ι : Type ?u.804612
E : Type u_1
F : Type ?u.804618
𝕜 : Type ?u.804621
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : BorelSpace E
f : β → E
hp : Fact (1 ≤ p)
hp_ne_top : p ≠ ⊤
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Memℒp f p
⊢ Tendsto
    (fun n =>
      Memℒp.toLp ↑(approxOn f fmeas (Set.range f ∪ {0}) 0 (_ : 0 ∈ Set.range f ∪ {0}) n)
        (_ : Memℒp (↑(approxOn f fmeas (Set.range f ∪ {0}) 0 (_ : 0 ∈ Set.range f ∪ {0}) n)) p))
    atTop (𝓝 (Memℒp.toLp f hf))
Theorem: CategoryTheory.Splitting.split_add
File: Mathlib/Algebra/Homology/ShortExact/Preadditive.lean

tactic: delta Splitting.section retraction
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : Preadditive 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ retraction h ≫ f + g ≫ section h = 𝟙 B

tactic: rw [← cancel_mono h.iso.hom, ← cancel_epi h.iso.inv]
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : Preadditive 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ (h.iso.hom ≫ biprod.fst) ≫ f + g ≫ biprod.inr ≫ h.iso.inv = 𝟙 B

tactic: simp only [Category.comp_id, Category.id_comp, Category.assoc, Iso.inv_hom_id_assoc,
  Iso.inv_hom_id, Limits.biprod.total, Preadditive.comp_add, Preadditive.add_comp,
  Splitting.comp_iso_eq_inl, Splitting.iso_comp_eq_snd_assoc]
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : Preadditive 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ h.iso.inv ≫ ((h.iso.hom ≫ biprod.fst) ≫ f + g ≫ biprod.inr ≫ h.iso.inv) ≫ h.iso.hom = h.iso.inv ≫ 𝟙 B ≫ h.iso.hom
Theorem: contDiff_iff_ftaylorSeries
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: constructor
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiff 𝕜 n f ↔ HasFTaylorSeriesUpTo n f (ftaylorSeries 𝕜 f)

tactic: rw [← contDiffOn_univ, ← hasFTaylorSeriesUpToOn_univ_iff, ← ftaylorSeriesWithin_univ]
state_before: case mp
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiff 𝕜 n f → HasFTaylorSeriesUpTo n f (ftaylorSeries 𝕜 f)

tactic: exact fun h => ContDiffOn.ftaylorSeriesWithin h uniqueDiffOn_univ
state_before: case mp
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiffOn 𝕜 n f univ → HasFTaylorSeriesUpToOn n f (ftaylorSeriesWithin 𝕜 f univ) univ

tactic: intro h
state_before: case mpr
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ HasFTaylorSeriesUpTo n f (ftaylorSeries 𝕜 f) → ContDiff 𝕜 n f

tactic: exact ⟨ftaylorSeries 𝕜 f, h⟩
state_before: case mpr
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f (ftaylorSeries 𝕜 f)
⊢ ContDiff 𝕜 n f
Theorem: Composition.sizeUpTo_index_le
File: Mathlib/Combinatorics/Composition.lean

tactic: by_contra H
state_before: n : ℕ
c : Composition n
j : Fin n
⊢ sizeUpTo c ↑(index c j) ≤ ↑j

tactic: set i := c.index j
state_before: n : ℕ
c : Composition n
j : Fin n
H : ¬sizeUpTo c ↑(index c j) ≤ ↑j
⊢ False

tactic: push_neg  at H
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ¬sizeUpTo c ↑i ≤ ↑j
⊢ False

tactic: have i_pos : (0 : ℕ) < i := by
  by_contra' i_pos
  revert H
  simp [nonpos_iff_eq_zero.1 i_pos, c.sizeUpTo_zero]
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
⊢ False

tactic: let i₁ := (i : ℕ).pred
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
⊢ False

tactic: have i₁_lt_i : i₁ < i := Nat.pred_lt (ne_of_gt i_pos)
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
i₁ : ℕ := Nat.pred ↑i
⊢ False

tactic: have i₁_succ : i₁.succ = i := Nat.succ_pred_eq_of_pos i_pos
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
i₁ : ℕ := Nat.pred ↑i
i₁_lt_i : i₁ < ↑i
⊢ False

tactic: have := Nat.find_min (c.index_exists j.2) i₁_lt_i
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
i₁ : ℕ := Nat.pred ↑i
i₁_lt_i : i₁ < ↑i
i₁_succ : Nat.succ i₁ = ↑i
⊢ False

tactic: simp [lt_trans i₁_lt_i (c.index j).2, i₁_succ] at this
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
i₁ : ℕ := Nat.pred ↑i
i₁_lt_i : i₁ < ↑i
i₁_succ : Nat.succ i₁ = ↑i
this : ¬(↑j < sizeUpTo c (Nat.succ i₁) ∧ i₁ < length c)
⊢ False

tactic: exact Nat.lt_le_antisymm H this
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : 0 < ↑i
i₁ : ℕ := Nat.pred ↑i
i₁_lt_i : i₁ < ↑i
i₁_succ : Nat.succ i₁ = ↑i
this : sizeUpTo c ↑(index c j) ≤ ↑j
⊢ False

tactic: by_contra' i_pos
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
⊢ 0 < ↑i

tactic: revert H
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
H : ↑j < sizeUpTo c ↑(index c j)
i_pos : ↑(index c j) ≤ 0
⊢ False

tactic: simp [nonpos_iff_eq_zero.1 i_pos, c.sizeUpTo_zero]
state_before: n : ℕ
c : Composition n
j : Fin n
i : Fin (length c) := index c j
i_pos : ↑(index c j) ≤ 0
⊢ ↑j < sizeUpTo c ↑(index c j) → False
Theorem: IsLocalizedModule.iso_symm_apply'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: erw [← IsLocalizedModule.eq_iff_exists S f, f.map_smul, f.map_smul, ← (surj' _).choose_spec,
← mul_smul, mul_comm, mul_smul, eq1]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.688815
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M'
a : M
b : { x // x ∈ S }
eq1 : b • m = ↑f a
⊢ ∃ u,
    u • b • (Exists.choose (_ : ∃ x, x.snd • m = ↑f x.fst)).fst =
      u • (Exists.choose (_ : ∃ x, x.snd • m = ↑f x.fst)).snd • a
Theorem: mul_le_iff_le_one_right
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : PosMulMono α
inst✝ : PosMulMonoRev α
a0 : 0 < a
⊢ a * b ≤ a ↔ a * b ≤ a * 1
Theorem: QuotientMap.of_quotientMap_compose
File: Mathlib/Topology/Maps.lean

tactic: rw [hgf.right, ← coinduced_compose]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.137691
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
hf : Continuous f
hg : Continuous g
hgf : QuotientMap (g ∘ f)
⊢ inst✝¹ ≤ coinduced g inst✝²

tactic: exact coinduced_mono hf.coinduced_le
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.137691
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
hf : Continuous f
hg : Continuous g
hgf : QuotientMap (g ∘ f)
⊢ coinduced g (coinduced f inst✝³) ≤ coinduced g inst✝²
Theorem: intervalIntegral.continuousOn_primitive_Icc
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: have aux : (fun x => ∫ t in Icc a x, f t ∂μ) = fun x => ∫ t in Ioc a x, f t ∂μ := by
  ext x
  exact integral_Icc_eq_integral_Ioc
state_before: ι : Type ?u.18353564
𝕜 : Type ?u.18353567
E : Type u_1
F : Type ?u.18353573
A : Type ?u.18353576
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b)
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Icc a x, f t ∂μ) (Icc a b)

tactic: rw [aux]
state_before: ι : Type ?u.18353564
𝕜 : Type ?u.18353567
E : Type u_1
F : Type ?u.18353573
A : Type ?u.18353576
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b)
aux : (fun x => ∫ (t : ℝ) in Icc a x, f t ∂μ) = fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Icc a x, f t ∂μ) (Icc a b)

tactic: exact continuousOn_primitive h_int
state_before: ι : Type ?u.18353564
𝕜 : Type ?u.18353567
E : Type u_1
F : Type ?u.18353573
A : Type ?u.18353576
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b)
aux : (fun x => ∫ (t : ℝ) in Icc a x, f t ∂μ) = fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ) (Icc a b)

tactic: ext x
state_before: ι : Type ?u.18353564
𝕜 : Type ?u.18353567
E : Type u_1
F : Type ?u.18353573
A : Type ?u.18353576
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b)
⊢ (fun x => ∫ (t : ℝ) in Icc a x, f t ∂μ) = fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ

tactic: exact integral_Icc_eq_integral_Ioc
state_before: case h
ι : Type ?u.18353564
𝕜 : Type ?u.18353567
E : Type u_1
F : Type ?u.18353573
A : Type ?u.18353576
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b)
x : ℝ
⊢ (∫ (t : ℝ) in Icc a x, f t ∂μ) = ∫ (t : ℝ) in Ioc a x, f t ∂μ
Theorem: LucasLehmer.residue_eq_zero_iff_sMod_eq_zero
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: dsimp [lucasLehmerResidue]
state_before: p : ℕ
w : 1 < p
⊢ lucasLehmerResidue p = 0 ↔ sMod p (p - 2) = 0

tactic: rw [sZMod_eq_sMod p]
state_before: p : ℕ
w : 1 < p
⊢ sZMod p (p - 2) = 0 ↔ sMod p (p - 2) = 0

tactic: constructor
state_before: p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 ↔ sMod p (p - 2) = 0

tactic: intro h
state_before: case mp
p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 → sMod p (p - 2) = 0

tactic: simp [ZMod.int_cast_zmod_eq_zero_iff_dvd] at h
state_before: case mp
p : ℕ
w : 1 < p
h : ↑(sMod p (p - 2)) = 0
⊢ sMod p (p - 2) = 0

tactic: apply Int.eq_zero_of_dvd_of_nonneg_of_lt _ _ h <;> clear h
state_before: case mp
p : ℕ
w : 1 < p
h : 2 ^ p - 1 ∣ sMod p (p - 2)
⊢ sMod p (p - 2) = 0

tactic: apply sMod_nonneg _ (Nat.lt_of_succ_lt w)
state_before: p : ℕ
w : 1 < p
⊢ 0 ≤ sMod p (p - 2)

tactic: exact sMod_lt _ (Nat.lt_of_succ_lt w) (p - 2)
state_before: p : ℕ
w : 1 < p
⊢ sMod p (p - 2) < 2 ^ p - 1

tactic: intro h
state_before: case mpr
p : ℕ
w : 1 < p
⊢ sMod p (p - 2) = 0 → ↑(sMod p (p - 2)) = 0

tactic: rw [h]
state_before: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑(sMod p (p - 2)) = 0

tactic: simp
state_before: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑0 = 0
Theorem: MeasureTheory.OuterMeasure.le_boundedBy'
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [le_boundedBy, forall_congr']
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), Set.Nonempty s → ↑μ s ≤ m s

tactic: intro s
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), ↑μ a ≤ m a ↔ Set.Nonempty a → ↑μ a ≤ m a

tactic: cases' s.eq_empty_or_nonempty with h h <;> simp [h]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ ↑μ s ≤ m s ↔ Set.Nonempty s → ↑μ s ≤ m s
Theorem: Finsupp.supported_comap_lmapDomain
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [← Set.image_subset_iff, ← Finset.coe_image] at hl
state_before: α : Type u_2
M : Type u_3
N : Type ?u.243431
P : Type ?u.243434
R : Type u_4
S : Type ?u.243440
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_1
α'' : Type ?u.243535
f : α → α'
s : Set α'
l : α →₀ M
hl : ↑l.support ⊆ f ⁻¹' s
⊢ ↑(mapDomain f l).support ⊆ s

tactic: exact Set.Subset.trans mapDomain_support hl
state_before: α : Type u_2
M : Type u_3
N : Type ?u.243431
P : Type ?u.243434
R : Type u_4
S : Type ?u.243440
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_1
α'' : Type ?u.243535
f : α → α'
s : Set α'
l : α →₀ M
hl✝ : f '' ↑l.support ⊆ s
hl : ↑(Finset.image f l.support) ⊆ s
⊢ ↑(mapDomain f l).support ⊆ s
Theorem: QuaternionGroup.card
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: rw [← Fintype.card_eq.mpr ⟨fintypeHelper⟩, Fintype.card_sum, ZMod.card, two_mul]
state_before: n : ℕ
inst✝ : NeZero n
⊢ Fintype.card (QuaternionGroup n) = 4 * n

tactic: ring
state_before: n : ℕ
inst✝ : NeZero n
⊢ n + n + (n + n) = 4 * n
Theorem: HasStrictFDerivAt.mul
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: convert hc.mul' hd
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.681201
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.681296
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.681391
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.683526
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasStrictFDerivAt c c' x
hd : HasStrictFDerivAt d d' x
⊢ HasStrictFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x

tactic: ext z
state_before: case h.e'_10.h.e'_6
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.681201
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.681296
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.681391
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.683526
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasStrictFDerivAt c c' x
hd : HasStrictFDerivAt d d' x
⊢ d x • c' = smulRight c' (d x)

tactic: apply mul_comm
state_before: case h.e'_10.h.e'_6.h
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.681201
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.681296
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.681391
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.683526
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasStrictFDerivAt c c' x
hd : HasStrictFDerivAt d d' x
z : E
⊢ ↑(d x • c') z = ↑(smulRight c' (d x)) z
Theorem: Function.range_subset_insert_image_mulSupport
File: Mathlib/Algebra/Support.lean

tactic: simpa only [range_subset_iff, mem_insert_iff, or_iff_not_imp_left] using
  fun x (hx : x ∈ mulSupport f) => mem_image_of_mem f hx
state_before: α : Type u_2
β : Type ?u.7733
A : Type ?u.7736
B : Type ?u.7739
M : Type u_1
N : Type ?u.7745
P : Type ?u.7748
R : Type ?u.7751
S : Type ?u.7754
G : Type ?u.7757
M₀ : Type ?u.7760
G₀ : Type ?u.7763
ι : Sort ?u.7766
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
⊢ range f ⊆ insert 1 (f '' mulSupport f)
Theorem: PFunctor.W.mk_dest
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: cases p
state_before: P : PFunctor
α β : Type u
p : W P
⊢ mk (dest p) = p

tactic: rfl
state_before: case mk
P : PFunctor
α β : Type u
a✝ : P.A
f✝ : B P a✝ → WType P.B
⊢ mk (dest (WType.mk a✝ f✝)) = WType.mk a✝ f✝
Theorem: MeasureTheory.Measure.restrict_iUnion_ae
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [sum_apply _ ht, restrict_iUnion_apply_ae hd hm ht]
state_before: α : Type u_2
β : Type ?u.359713
γ : Type ?u.359716
δ : Type ?u.359719
ι : Type u_1
R : Type ?u.359725
R' : Type ?u.359728
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
hm : ∀ (i : ι), NullMeasurableSet (s i)
t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ (⋃ (i : ι), s i)) t = ↑↑(sum fun i => restrict μ (s i)) t
Theorem: Rat.mkRat_zero
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mkRat_def]
state_before: n : Int
⊢ mkRat n 0 = 0
Theorem: Nat.div2_val
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: refine'
  Nat.eq_of_mul_eq_mul_left (by decide)
    (Nat.add_left_cancel (Eq.trans _ (Nat.mod_add_div n 2).symm))
state_before: n : ℕ
⊢ div2 n = n / 2

tactic: rw [mod_two_of_bodd, bodd_add_div2]
state_before: n : ℕ
⊢ n % 2 + 2 * div2 n = n

tactic: decide
state_before: n : ℕ
⊢ 0 < 2
Theorem: List.rdrop_concat_succ
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rdrop_eq_reverse_drop_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rdrop (l ++ [x]) (n + 1) = rdrop l n
Theorem: Polynomial.roots_X
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [← roots_X_sub_C, C_0, sub_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]
⊢ roots X = {0}
Theorem: Filter.tendsto_const_mul_atTop_iff_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine' ⟨fun hrf => not_le.mp fun hr => _, fun hr => (tendsto_const_mul_atTop_of_pos hr).mpr h⟩
state_before: ι : Type ?u.217364
ι' : Type ?u.217367
α : Type u_2
β : Type u_1
γ : Type ?u.217376
inst✝¹ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
inst✝ : NeBot l
h : Tendsto f l atTop
⊢ Tendsto (fun x => r * f x) l atTop ↔ 0 < r

tactic: rcases ((h.eventually_ge_atTop 0).and (hrf.eventually_gt_atTop 0)).exists with ⟨x, hx, hrx⟩
state_before: ι : Type ?u.217364
ι' : Type ?u.217367
α : Type u_2
β : Type u_1
γ : Type ?u.217376
inst✝¹ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
inst✝ : NeBot l
h : Tendsto f l atTop
hrf : Tendsto (fun x => r * f x) l atTop
hr : r ≤ 0
⊢ False

tactic: exact (mul_nonpos_of_nonpos_of_nonneg hr hx).not_lt hrx
state_before: case intro.intro
ι : Type ?u.217364
ι' : Type ?u.217367
α : Type u_2
β : Type u_1
γ : Type ?u.217376
inst✝¹ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
inst✝ : NeBot l
h : Tendsto f l atTop
hrf : Tendsto (fun x => r * f x) l atTop
hr : r ≤ 0
x : β
hx : 0 ≤ f x
hrx : 0 < r * f x
⊢ False