tasksource/leandojo huggingface dataset:
Theorem: Real.contDiff_rpow_const_of_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: induction' n with n ihn generalizing p
state_before: z x y p : ℝ
n : ℕ
h : ↑n ≤ p
⊢ ContDiff ℝ ↑n fun x => x ^ p

tactic: exact contDiff_zero.2 (continuous_id.rpow_const fun x => Or.inr <| by simpa using h)
state_before: case zero
z x y p✝ : ℝ
n : ℕ
h✝ : ↑n ≤ p✝
p : ℝ
h : ↑Nat.zero ≤ p
⊢ ContDiff ℝ ↑Nat.zero fun x => x ^ p

tactic: simpa using h
state_before: z x✝ y p✝ : ℝ
n : ℕ
h✝ : ↑n ≤ p✝
p : ℝ
h : ↑Nat.zero ≤ p
x : ℝ
⊢ 0 ≤ p

tactic: have h1 : 1 ≤ p := le_trans (by simp) h
state_before: case succ
z x y p✝ : ℝ
n✝ : ℕ
h✝ : ↑n✝ ≤ p✝
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(Nat.succ n) ≤ p
⊢ ContDiff ℝ ↑(Nat.succ n) fun x => x ^ p

tactic: rw [Nat.cast_succ, ← le_sub_iff_add_le] at h
state_before: case succ
z x y p✝ : ℝ
n✝ : ℕ
h✝ : ↑n✝ ≤ p✝
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(Nat.succ n) ≤ p
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(Nat.succ n) fun x => x ^ p

tactic: rw [contDiff_succ_iff_deriv, deriv_rpow_const' h1]
state_before: case succ
z x y p✝ : ℝ
n✝ : ℕ
h✝ : ↑n✝ ≤ p✝
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(Nat.succ n) fun x => x ^ p

tactic: refine' ⟨differentiable_rpow_const h1, contDiff_const.mul (ihn h)⟩
state_before: case succ
z x y p✝ : ℝ
n✝ : ℕ
h✝ : ↑n✝ ≤ p✝
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ (Differentiable ℝ fun x => x ^ p) ∧ ContDiff ℝ ↑n fun x => p * x ^ (p - 1)

tactic: simp
state_before: z x y p✝ : ℝ
n✝ : ℕ
h✝ : ↑n✝ ≤ p✝
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(Nat.succ n) ≤ p
⊢ 1 ≤ ↑(Nat.succ n)
Theorem: PadicSeq.norm_eq_pow_val
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [norm, valuation, dif_neg hf, dif_neg hf, padicNorm, if_neg]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
⊢ norm f = ↑p ^ (-valuation f)

tactic: intro H
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
⊢ ¬↑f (stationaryPoint hf) = 0

tactic: apply CauSeq.not_limZero_of_not_congr_zero hf
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
⊢ False

tactic: intro ε hε
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
⊢ LimZero f

tactic: use stationaryPoint hf
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
ε : ℚ
hε : ε > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → padicNorm p (↑f j) < ε

tactic: intro n hn
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
ε : ℚ
hε : ε > 0
⊢ ∀ (j : ℕ), j ≥ stationaryPoint hf → padicNorm p (↑f j) < ε

tactic: rw [stationaryPoint_spec hf le_rfl hn]
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
ε : ℚ
hε : ε > 0
n : ℕ
hn : n ≥ stationaryPoint hf
⊢ padicNorm p (↑f n) < ε

tactic: simpa [H] using hε
state_before: case hnc
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
H : ↑f (stationaryPoint hf) = 0
ε : ℚ
hε : ε > 0
n : ℕ
hn : n ≥ stationaryPoint hf
⊢ padicNorm p (↑f (stationaryPoint hf)) < ε
Theorem: List.append_join_map_append
File: Mathlib/Data/List/Join.lean

tactic: induction' L with _ _ ih
state_before: α : Type u_1
β : Type ?u.18108
L : List (List α)
x : List α
⊢ x ++ join (map (fun l => l ++ x) L) = join (map (fun l => x ++ l) L) ++ x

tactic: rw [map_nil, join, append_nil, map_nil, join, nil_append]
state_before: case nil
α : Type u_1
β : Type ?u.18108
x : List α
⊢ x ++ join (map (fun l => l ++ x) []) = join (map (fun l => x ++ l) []) ++ x

tactic: rw [map_cons, join, map_cons, join, append_assoc, ih, append_assoc, append_assoc]
state_before: case cons
α : Type u_1
β : Type ?u.18108
x head✝ : List α
tail✝ : List (List α)
ih : x ++ join (map (fun l => l ++ x) tail✝) = join (map (fun l => x ++ l) tail✝) ++ x
⊢ x ++ join (map (fun l => l ++ x) (head✝ :: tail✝)) = join (map (fun l => x ++ l) (head✝ :: tail✝)) ++ x
Theorem: iSup_univ
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.113506
γ : Type ?u.113509
ι : Sort ?u.113512
ι' : Sort ?u.113515
κ : ι → Sort ?u.113520
κ' : ι' → Sort ?u.113525
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ (⨆ (x : β) (_ : x ∈ univ), f x) = ⨆ (x : β), f x
Theorem: Set.pi_univ_Ioc_update_left
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: have : Ioc m (y i₀) = Ioi m ∩ Ioc (x i₀) (y i₀) := by
  rw [← Ioi_inter_Iic, ← Ioi_inter_Iic, ← inter_assoc,
    inter_eq_self_of_subset_left (Ioi_subset_Ioi hm)]
state_before: ι : Type u_2
α : ι → Type u_1
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : x i₀ ≤ m
⊢ (pi univ fun i => Ioc (update x i₀ m i) (y i)) = {z | m < z i₀} ∩ pi univ fun i => Ioc (x i) (y i)

tactic: simp_rw [univ_pi_update i₀ _ _ fun i z ↦ Ioc z (y i), ← pi_inter_compl ({i₀} : Set ι),
  singleton_pi', ← inter_assoc, this]
state_before: ι : Type u_2
α : ι → Type u_1
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : x i₀ ≤ m
this : Ioc m (y i₀) = Ioi m ∩ Ioc (x i₀) (y i₀)
⊢ (pi univ fun i => Ioc (update x i₀ m i) (y i)) = {z | m < z i₀} ∩ pi univ fun i => Ioc (x i) (y i)

tactic: rfl
state_before: ι : Type u_2
α : ι → Type u_1
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : x i₀ ≤ m
this : Ioc m (y i₀) = Ioi m ∩ Ioc (x i₀) (y i₀)
⊢ ({x_1 | x_1 i₀ ∈ Ioi m ∩ Ioc (x i₀) (y i₀)} ∩ pi ({i₀}ᶜ) fun j => Ioc (x j) (y j)) =
    {z | m < z i₀} ∩ {x_1 | x_1 i₀ ∈ Ioc (x i₀) (y i₀)} ∩ pi ({i₀}ᶜ) fun j => Ioc (x j) (y j)

tactic: rw [← Ioi_inter_Iic, ← Ioi_inter_Iic, ← inter_assoc,
  inter_eq_self_of_subset_left (Ioi_subset_Ioi hm)]
state_before: ι : Type u_2
α : ι → Type u_1
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : x i₀ ≤ m
⊢ Ioc m (y i₀) = Ioi m ∩ Ioc (x i₀) (y i₀)
Theorem: Function.bUnion_ptsOfPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp [mem_periodicPts]
state_before: α : Type u_1
β : Type ?u.11680
f fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
x : α
⊢ (x ∈ ⋃ (n : ℕ) (_ : n > 0), ptsOfPeriod f n) ↔ x ∈ periodicPts f
Theorem: Sylow.mem_fixedPoints_mul_left_cosets_iff_mem_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [mul_inv_rev, inv_inv] at this
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints { x // x ∈ H } (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit { x // x ∈ H } ↑x → y = ↑x
n : G
hn : n ∈ H
this : (n⁻¹ * x)⁻¹ * x ∈ H
⊢ x⁻¹ * n * x⁻¹⁻¹ ∈ H

tactic: convert this
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints { x // x ∈ H } (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit { x // x ∈ H } ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹ * n * x⁻¹⁻¹ ∈ H

tactic: rw [inv_inv]
state_before: case h.e'_4.h.e'_6
G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints { x // x ∈ H } (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit { x // x ∈ H } ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹⁻¹ = x

tactic: rw [hx] at hb₂
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ∀ (n : G), n ∈ H ↔ x * n * x⁻¹ ∈ H
y✝ : G ⧸ H
y : G
hy : Quotient.mk'' y ∈ orbit { x // x ∈ H } ↑x
b : G
hb₁ : b ∈ H
hb₂✝ : (fun x_1 => x_1 • ↑x) { val := b, property := hb₁ } = Quotient.mk'' y
hb₂ : (b * x)⁻¹ * y ∈ H
⊢ b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H

tactic: simpa [mul_inv_rev, mul_assoc] using hb₂
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ∀ (n : G), n ∈ H ↔ x * n * x⁻¹ ∈ H
y✝ : G ⧸ H
y : G
hy : Quotient.mk'' y ∈ orbit { x // x ∈ H } ↑x
b : G
hb₁ : b ∈ H
hb₂✝ : (fun x_1 => x_1 • ↑x) { val := b, property := hb₁ } = Quotient.mk'' y
hb₂ : x * ((b * x)⁻¹ * y) * x⁻¹ ∈ H
⊢ b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H
Theorem: MeasureTheory.SignedMeasure.toJordanDecomposition_spec
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: set i := choose s.exists_compl_positive_negative
state_before: α : Type u_1
β : Type ?u.37523
inst✝² : MeasurableSpace α
s✝ : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
s : SignedMeasure α
⊢ ∃ i hi₁ hi₂ hi₃,
    (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂ ∧
      (toJordanDecomposition s).negPart = toMeasureOfLEZero s (iᶜ) (_ : MeasurableSet (iᶜ)) hi₃

tactic: obtain ⟨hi₁, hi₂, hi₃⟩ := choose_spec s.exists_compl_positive_negative
state_before: α : Type u_1
β : Type ?u.37523
inst✝² : MeasurableSpace α
s✝ : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
s : SignedMeasure α
i : Set α :=
  choose
    (_ :
      ∃ i,
        MeasurableSet i ∧
          VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
            VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ))
⊢ ∃ i hi₁ hi₂ hi₃,
    (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂ ∧
      (toJordanDecomposition s).negPart = toMeasureOfLEZero s (iᶜ) (_ : MeasurableSet (iᶜ)) hi₃

tactic: exact ⟨i, hi₁, hi₂, hi₃, rfl, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.37523
inst✝² : MeasurableSpace α
s✝ : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
s : SignedMeasure α
i : Set α :=
  choose
    (_ :
      ∃ i,
        MeasurableSet i ∧
          VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
            VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ))
hi₁ :
  MeasurableSet
    (choose
      (_ :
        ∃ i,
          MeasurableSet i ∧
            VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
              VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ)))
hi₂ :
  VectorMeasure.restrict 0
      (choose
        (_ :
          ∃ i,
            MeasurableSet i ∧
              VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
                VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ))) ≤
    VectorMeasure.restrict s
      (choose
        (_ :
          ∃ i,
            MeasurableSet i ∧
              VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
                VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ)))
hi₃ :
  VectorMeasure.restrict s
      (choose
          (_ :
            ∃ i,
              MeasurableSet i ∧
                VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
                  VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ))ᶜ) ≤
    VectorMeasure.restrict 0
      (choose
          (_ :
            ∃ i,
              MeasurableSet i ∧
                VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i ∧
                  VectorMeasure.restrict s (iᶜ) ≤ VectorMeasure.restrict 0 (iᶜ))ᶜ)
⊢ ∃ i hi₁ hi₂ hi₃,
    (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂ ∧
      (toJordanDecomposition s).negPart = toMeasureOfLEZero s (iᶜ) (_ : MeasurableSet (iᶜ)) hi₃
Theorem: Turing.PartrecToTM2.copy_ok
File: Mathlib/Computability/TMToPartrec.lean

tactic: induction' b with x b IH generalizing a d s
state_before: q : Λ'
s : Option Γ'
a b c d : List Γ'
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d }
    { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) }

tactic: refine' TransGen.head rfl _
state_before: case cons
q : Λ'
s✝ : Option Γ'
a✝ c d✝ : List Γ'
x : Γ'
b : List Γ'
IH :
  ∀ (s : Option Γ') (a d : List Γ'),
    Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d }
      { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) }
s : Option Γ'
a d : List Γ'
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a (x :: b) c d }
    { l := some q, var := none, stk := elim (List.reverseAux (x :: b) a) [] c (List.reverseAux (x :: b) d) }

tactic: simp
state_before: case cons
q : Λ'
s✝ : Option Γ'
a✝ c d✝ : List Γ'
x : Γ'
b : List Γ'
IH :
  ∀ (s : Option Γ') (a d : List Γ'),
    Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d }
      { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) }
s : Option Γ'
a d : List Γ'
⊢ TransGen (fun a b => b ∈ TM2.step tr a) (TM2.stepAux (tr (Λ'.copy q)) s (elim a (x :: b) c d))
    { l := some q, var := none, stk := elim (List.reverseAux (x :: b) a) [] c (List.reverseAux (x :: b) d) }

tactic: exact IH _ _ _
state_before: case cons
q : Λ'
s✝ : Option Γ'
a✝ c d✝ : List Γ'
x : Γ'
b : List Γ'
IH :
  ∀ (s : Option Γ') (a d : List Γ'),
    Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d }
      { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) }
s : Option Γ'
a d : List Γ'
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    { l := some (Λ'.copy q), var := some x, stk := elim (Option.iget (some x) :: a) b c (Option.iget (some x) :: d) }
    { l := some q, var := none, stk := elim (List.reverseAux b (x :: a)) [] c (List.reverseAux b (x :: d)) }

tactic: refine' TransGen.single _
state_before: case nil
q : Λ'
s✝ : Option Γ'
a✝ c d✝ : List Γ'
s : Option Γ'
a d : List Γ'
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a [] c d }
    { l := some q, var := none, stk := elim (List.reverseAux [] a) [] c (List.reverseAux [] d) }

tactic: simp
state_before: case nil
q : Λ'
s✝ : Option Γ'
a✝ c d✝ : List Γ'
s : Option Γ'
a d : List Γ'
⊢ { l := some q, var := none, stk := elim (List.reverseAux [] a) [] c (List.reverseAux [] d) } ∈
    TM2.step tr { l := some (Λ'.copy q), var := s, stk := elim a [] c d }
Theorem: Complex.isTheta_cpow_const_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: convert hl
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
b : ℂ
hl : b.re = 0 → b ≠ 0 → ∀ᶠ (x : α) in l, f x ≠ 0
⊢ ∀ᶠ (x : α) in l, f x = 0 → b.re = 0 → b = 0

tactic: rw [eventually_imp_distrib_right]
state_before: case a
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℂ
hl : b.re = 0 → b ≠ 0 → ∀ᶠ (x : α) in l, f x ≠ 0
⊢ (∀ᶠ (x : α) in l, f x = 0 → b.re = 0 → b = 0) ↔ b.re = 0 → b ≠ 0 → ∀ᶠ (x : α) in l, f x ≠ 0

tactic: tauto
state_before: case a
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℂ
hl : b.re = 0 → b ≠ 0 → ∀ᶠ (x : α) in l, f x ≠ 0
⊢ (∃ᶠ (x : α) in l, f x = 0) → b.re = 0 → b = 0 ↔ b.re = 0 → b ≠ 0 → ∀ᶠ (x : α) in l, f x ≠ 0
Theorem: Metric.Sigma.one_le_dist_of_ne
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: rw [Sigma.dist_ne h x y]
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i j : ι
h : i ≠ j
x : E i
y : E j
⊢ 1 ≤ dist { fst := i, snd := x } { fst := j, snd := y }

tactic: linarith [@dist_nonneg _ _ x (Nonempty.some ⟨x⟩), @dist_nonneg _ _ (Nonempty.some ⟨y⟩) y]
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i j : ι
h : i ≠ j
x : E i
y : E j
⊢ 1 ≤ dist x (Nonempty.some (_ : Nonempty (E i))) + 1 + dist (Nonempty.some (_ : Nonempty (E j))) y
Theorem: Seminorm.symmetric_ball_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [norm_neg, norm_one]
state_before: R : Type ?u.1254732
R' : Type ?u.1254735
𝕜 : Type u_2
𝕜₂ : Type ?u.1254741
𝕜₃ : Type ?u.1254744
𝕝 : Type ?u.1254747
E : Type u_1
E₂ : Type ?u.1254753
E₃ : Type ?u.1254756
F : Type ?u.1254759
G : Type ?u.1254762
ι : Type ?u.1254765
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x : E
r : ℝ
hx : x ∈ ball p 0 r
⊢ ‖-1‖ ≤ 1

tactic: simp only [neg_smul, one_smul]
state_before: R : Type ?u.1254732
R' : Type ?u.1254735
𝕜 : Type u_2
𝕜₂ : Type ?u.1254741
𝕜₃ : Type ?u.1254744
𝕝 : Type ?u.1254747
E : Type u_1
E₂ : Type ?u.1254753
E₃ : Type ?u.1254756
F : Type ?u.1254759
G : Type ?u.1254762
ι : Type ?u.1254765
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x : E
r : ℝ
hx : x ∈ ball p 0 r
⊢ (fun x => -1 • x) x = -x
Theorem: Polynomial.sum_zero_index
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp [sum]
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
S : Type u_1
inst✝ : AddCommMonoid S
f : ℕ → R → S
⊢ sum 0 f = 0
Theorem: dite_eq_iff
File: Mathlib/Logic/Basic.lean

tactic: by_cases P <;> simp [*, exists_prop_of_true, exists_prop_of_false]
state_before: α : Sort u_1
β : Sort ?u.32627
σ : α → Sort ?u.32623
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ dite P A B = c ↔ (∃ h, A h = c) ∨ ∃ h, B h = c
Theorem: List.isRotated_iff_mem_map_range
File: Mathlib/Data/List/Rotate.lean

tactic: simp_rw [mem_map, mem_range, isRotated_iff_mod]
state_before: α : Type u
l l' : List α
⊢ l ~r l' ↔ l' ∈ map (rotate l) (range (length l + 1))

tactic: exact
  ⟨fun ⟨n, hn, h⟩ => ⟨n, Nat.lt_succ_of_le hn, h⟩,
    fun ⟨n, hn, h⟩ => ⟨n, Nat.le_of_lt_succ hn, h⟩⟩
state_before: α : Type u
l l' : List α
⊢ (∃ n, n ≤ length l ∧ rotate l n = l') ↔ ∃ a, a < length l + 1 ∧ rotate l a = l'
Theorem: Composition.ones_blocksFun
File: Mathlib/Combinatorics/Composition.lean

tactic: simp only [blocksFun, ones, blocks, i.2, List.nthLe_replicate]
state_before: n✝ : ℕ
c : Composition n✝
n : ℕ
i : Fin (length (ones n))
⊢ blocksFun (ones n) i = 1
Theorem: is_semisimple_of_sSup_simples_eq_top
File: Mathlib/RingTheory/SimpleModule.lean

tactic: simp_rw [← h, isSimpleModule_iff_isAtom]
state_before: R : Type u_2
inst✝⁴ : Ring R
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.36053
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : sSup {m | IsSimpleModule R { x // x ∈ m }} = ⊤
⊢ sSup {a | IsAtom a} = ⊤
Theorem: div_neg_self
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [div_neg_eq_neg_div, div_self h]
state_before: α : Type ?u.38193
β : Type ?u.38196
K : Type u_1
inst✝ : DivisionRing K
a✝ b c d a : K
h : a ≠ 0
⊢ a / -a = -1
Theorem: Interval.coe_dual
File: Mathlib/Order/Interval.lean

tactic: cases s with
| none => rfl
| some s₀ => exact NonemptyInterval.coe_dual s₀
state_before: α : Type u_1
β : Type ?u.27118
γ : Type ?u.27121
δ : Type ?u.27124
ι : Sort ?u.27127
κ : ι → Sort ?u.27132
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
s✝ t : Interval α
a b : α
s : Interval α
⊢ ↑(↑dual s) = ↑ofDual ⁻¹' ↑s

tactic: rfl
state_before: case none
α : Type u_1
β : Type ?u.27118
γ : Type ?u.27121
δ : Type ?u.27124
ι : Sort ?u.27127
κ : ι → Sort ?u.27132
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
s t : Interval α
a b : α
⊢ ↑(↑dual none) = ↑ofDual ⁻¹' ↑none

tactic: exact NonemptyInterval.coe_dual s₀
state_before: case some
α : Type u_1
β : Type ?u.27118
γ : Type ?u.27121
δ : Type ?u.27124
ι : Sort ?u.27127
κ : ι → Sort ?u.27132
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
s t : Interval α
a b : α
s₀ : NonemptyInterval α
⊢ ↑(↑dual (some s₀)) = ↑ofDual ⁻¹' ↑(some s₀)
Theorem: Real.cos_int_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero] using (cos_periodic.int_mul n).add_antiperiod_eq cos_antiperiodic
state_before: n : ℤ
⊢ cos (↑n * (2 * π) + π) = -1
Theorem: SimpleGraph.Walk.support_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [support_append, *]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ support (reverse p) = List.reverse (support p)
Theorem: Fin.succRecOn_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: cases i
state_before: n✝ m : ℕ
C : (n : ℕ) → Fin n → Sort u_1
H0 : (n : ℕ) → C (n + 1) 0
Hs : (n : ℕ) → (i : Fin n) → C n i → C (Nat.succ n) (succ i)
n : ℕ
i : Fin n
⊢ succRecOn (succ i) H0 Hs = Hs n i (succRecOn i H0 Hs)

tactic: rfl
state_before: case mk
n✝ m : ℕ
C : (n : ℕ) → Fin n → Sort u_1
H0 : (n : ℕ) → C (n + 1) 0
Hs : (n : ℕ) → (i : Fin n) → C n i → C (Nat.succ n) (succ i)
n val✝ : ℕ
isLt✝ : val✝ < n
⊢ succRecOn (succ { val := val✝, isLt := isLt✝ }) H0 Hs =
    Hs n { val := val✝, isLt := isLt✝ } (succRecOn { val := val✝, isLt := isLt✝ } H0 Hs)
Theorem: Set.inv_range
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_inv]
state_before: F : Type ?u.7720
α : Type u_2
β : Type ?u.7726
γ : Type ?u.7729
inst✝ : InvolutiveInv α
s t : Set α
a : α
ι : Sort u_1
f : ι → α
⊢ (range f)⁻¹ = range fun i => (f i)⁻¹

tactic: exact (range_comp _ _).symm
state_before: F : Type ?u.7720
α : Type u_2
β : Type ?u.7726
γ : Type ?u.7729
inst✝ : InvolutiveInv α
s t : Set α
a : α
ι : Sort u_1
f : ι → α
⊢ Inv.inv '' range f = range fun i => (f i)⁻¹
Theorem: Polynomial.eval₂_reflect_eq_zero_iff
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: conv_rhs => rw [← eval₂_reflect_mul_pow i x N f hf]
state_before: R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ eval₂ i (⅟x) (reflect N f) = 0 ↔ eval₂ i x f = 0

tactic: constructor
state_before: R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ eval₂ i (⅟x) (reflect N f) = 0 ↔ eval₂ i (⅟x) (reflect N f) * x ^ N = 0

tactic: intro h
state_before: case mp
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ eval₂ i (⅟x) (reflect N f) = 0 → eval₂ i (⅟x) (reflect N f) * x ^ N = 0

tactic: rw [h, zero_mul]
state_before: case mp
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
h : eval₂ i (⅟x) (reflect N f) = 0
⊢ eval₂ i (⅟x) (reflect N f) * x ^ N = 0

tactic: intro h
state_before: case mpr
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ eval₂ i (⅟x) (reflect N f) * x ^ N = 0 → eval₂ i (⅟x) (reflect N f) = 0

tactic: rw [← mul_one (eval₂ i (⅟ x) _), ← one_pow N, ← mul_invOf_self x, mul_pow, ← mul_assoc, h,
  zero_mul]
state_before: case mpr
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
h : eval₂ i (⅟x) (reflect N f) * x ^ N = 0
⊢ eval₂ i (⅟x) (reflect N f) = 0
Theorem: ConvexOn.add
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.30465
α : Type ?u.30468
β : Type u_3
ι : Type ?u.30474
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : SMul 𝕜 E
inst✝ : DistribMulAction 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
hg : ConvexOn 𝕜 s g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y + (a • g x + b • g y) = a • (f x + g x) + b • (f y + g y)
Theorem: Int.ceil_natCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, ← cast_ofNat, cast_le]
state_before: F : Type ?u.211444
α : Type u_1
β : Type ?u.211450
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ : α
n : ℕ
a : ℤ
⊢ ⌈↑n⌉ ≤ a ↔ ↑n ≤ a