tasksource/leandojo huggingface dataset:
Theorem: Nat.succ_dvd_centralBinom
File: Mathlib/Data/Nat/Choose/Central.lean

tactic: have h_s : (n + 1).coprime (2 * n + 1) := by
  rw [two_mul, add_assoc, coprime_add_self_right, coprime_self_add_left]
  exact coprime_one_left n
state_before: n : ℕ
⊢ n + 1 ∣ centralBinom n

tactic: apply h_s.dvd_of_dvd_mul_left
state_before: n : ℕ
h_s : coprime (n + 1) (2 * n + 1)
⊢ n + 1 ∣ centralBinom n

tactic: apply Nat.dvd_of_mul_dvd_mul_left zero_lt_two
state_before: n : ℕ
h_s : coprime (n + 1) (2 * n + 1)
⊢ n + 1 ∣ (2 * n + 1) * centralBinom n

tactic: rw [← mul_assoc, ← succ_mul_centralBinom_succ, mul_comm]
state_before: n : ℕ
h_s : coprime (n + 1) (2 * n + 1)
⊢ 2 * (n + 1) ∣ 2 * ((2 * n + 1) * centralBinom n)

tactic: exact mul_dvd_mul_left _ (two_dvd_centralBinom_succ n)
state_before: n : ℕ
h_s : coprime (n + 1) (2 * n + 1)
⊢ (n + 1) * 2 ∣ (n + 1) * centralBinom (n + 1)

tactic: rw [two_mul, add_assoc, coprime_add_self_right, coprime_self_add_left]
state_before: n : ℕ
⊢ coprime (n + 1) (2 * n + 1)

tactic: exact coprime_one_left n
state_before: n : ℕ
⊢ coprime 1 n
Theorem: Set.sigmaToiUnion_surjective
File: Mathlib/Data/Set/Lattice.lean

tactic: simpa using hb
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.299540
ι : Sort ?u.299543
ι' : Sort ?u.299546
ι₂ : Sort ?u.299549
κ : ι → Sort ?u.299554
κ₁ : ι → Sort ?u.299559
κ₂ : ι → Sort ?u.299564
κ' : ι' → Sort ?u.299569
t : α → Set β
b : β
hb : b ∈ ⋃ (i : α), t i
⊢ ∃ a, b ∈ t a
Theorem: Nat.Prime.properDivisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [← erase_insert properDivisors.not_self_mem, insert_self_properDivisors pp.ne_zero,
  pp.divisors, pair_comm, erase_insert fun con => pp.ne_one (mem_singleton.1 con)]
state_before: n p : ℕ
pp : Prime p
⊢ Nat.properDivisors p = {1}
Theorem: ConjAct.fixedPoints_eq_center
File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

tactic: ext x
state_before: α : Type ?u.77795
M : Type ?u.77798
G : Type u_1
G₀ : Type ?u.77804
R : Type ?u.77807
K : Type ?u.77810
inst✝ : Group G
⊢ fixedPoints (ConjAct G) G = ↑(center G)

tactic: simp [mem_center_iff, smul_def, mul_inv_eq_iff_eq_mul]
state_before: case h
α : Type ?u.77795
M : Type ?u.77798
G : Type u_1
G₀ : Type ?u.77804
R : Type ?u.77807
K : Type ?u.77810
inst✝ : Group G
x : G
⊢ x ∈ fixedPoints (ConjAct G) G ↔ x ∈ ↑(center G)
Theorem: MeasureTheory.FiniteMeasure.restrict_mass
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp only [mass, restrict_apply μ A MeasurableSet.univ, univ_inter]
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.39681
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ mass (restrict μ A) = (fun s => ENNReal.toNNReal (↑↑↑μ s)) A
Theorem: MeasureTheory.mem_map_restrict_ae_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [mem_map, mem_ae_iff, Measure.restrict_apply' hs]
state_before: α : Type u_2
β✝ : Type ?u.579235
γ : Type ?u.579238
δ : Type ?u.579241
ι : Type ?u.579244
R : Type ?u.579247
R' : Type ?u.579250
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β✝
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
β : Type u_1
s : Set α
t : Set β
f : α → β
hs : MeasurableSet s
⊢ t ∈ Filter.map f (ae (Measure.restrict μ s)) ↔ ↑↑μ ((f ⁻¹' t)ᶜ ∩ s) = 0
Theorem: Cardinal.lift_iInf
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: unfold iInf
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal
⊢ lift (iInf f) = ⨅ (i : ι), lift (f i)

tactic: convert lift_sInf (range f)
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal
⊢ lift (sInf (range f)) = sInf (range fun i => lift (f i))

tactic: simp_rw [←comp_apply (f := lift), range_comp]
state_before: case h.e'_3.h.e'_3
α β : Type u
ι : Sort u_1
f : ι → Cardinal
⊢ (range fun i => lift (f i)) = lift '' range f
Theorem: MeasureTheory.Memℒp.integrable_norm_rpow'
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: by_cases h_zero : p = 0
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.835159
δ : Type ?u.835162
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p
⊢ Integrable fun x => ‖f x‖ ^ ENNReal.toReal p

tactic: by_cases h_top : p = ∞
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.835159
δ : Type ?u.835162
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p
h_zero : ¬p = 0
⊢ Integrable fun x => ‖f x‖ ^ ENNReal.toReal p

tactic: exact hf.integrable_norm_rpow h_zero h_top
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.835159
δ : Type ?u.835162
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p
h_zero : ¬p = 0
h_top : ¬p = ⊤
⊢ Integrable fun x => ‖f x‖ ^ ENNReal.toReal p

tactic: simp [h_zero, integrable_const]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.835159
δ : Type ?u.835162
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p
h_zero : p = 0
⊢ Integrable fun x => ‖f x‖ ^ ENNReal.toReal p

tactic: simp [h_top, integrable_const]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.835159
δ : Type ?u.835162
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p
h_zero : ¬p = 0
h_top : p = ⊤
⊢ Integrable fun x => ‖f x‖ ^ ENNReal.toReal p
Theorem: List.getLast_append'
File: Mathlib/Data/List/Basic.lean

tactic: induction' l₁ with _ _ ih
state_before: ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
h : l₂ ≠ []
⊢ getLast (l₁ ++ l₂) (_ : l₁ ++ l₂ ≠ []) = getLast l₂ h

tactic: simp
state_before: case nil
ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h : l₂ ≠ []
⊢ getLast ([] ++ l₂) (_ : [] ++ l₂ ≠ []) = getLast l₂ h

tactic: simp only [cons_append]
state_before: case cons
ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h : l₂ ≠ []
head✝ : α
tail✝ : List α
ih : getLast (tail✝ ++ l₂) (_ : tail✝ ++ l₂ ≠ []) = getLast l₂ h
⊢ getLast (head✝ :: tail✝ ++ l₂) (_ : head✝ :: tail✝ ++ l₂ ≠ []) = getLast l₂ h

tactic: rw [List.getLast_cons]
state_before: case cons
ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h : l₂ ≠ []
head✝ : α
tail✝ : List α
ih : getLast (tail✝ ++ l₂) (_ : tail✝ ++ l₂ ≠ []) = getLast l₂ h
⊢ getLast (head✝ :: (tail✝ ++ l₂)) (_ : head✝ :: (tail✝ ++ l₂) ≠ []) = getLast l₂ h

tactic: exact ih
state_before: case cons
ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h : l₂ ≠ []
head✝ : α
tail✝ : List α
ih : getLast (tail✝ ++ l₂) (_ : tail✝ ++ l₂ ≠ []) = getLast l₂ h
⊢ getLast (tail✝ ++ l₂) ?cons = getLast l₂ h

case cons
ι : Type ?u.30314
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h : l₂ ≠ []
head✝ : α
tail✝ : List α
ih : getLast (tail✝ ++ l₂) (_ : tail✝ ++ l₂ ≠ []) = getLast l₂ h
⊢ tail✝ ++ l₂ ≠ []
Theorem: Complex.conj_eq_iff_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rintro ⟨r, rfl⟩
state_before: z : ℂ
⊢ (∃ r, z = ↑r) → ↑z.re = z

tactic: simp [ofReal']
state_before: case intro
r : ℝ
⊢ ↑(↑r).re = ↑r
Theorem: mul_bit1
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: dsimp [bit1]
state_before: α : Type ?u.271140
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonAssocRing R
n r : R
⊢ r * bit1 n = 2 • (r * n) + r

tactic: rw [mul_add, mul_bit0, mul_one]
state_before: α : Type ?u.271140
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonAssocRing R
n r : R
⊢ r * (bit0 n + 1) = 2 • (r * n) + r
Theorem: MeasureTheory.IntegrableOn.integrable_of_ae_not_mem_eq_zero
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [← integrableOn_univ]
state_before: α : Type u_1
β : Type ?u.1651966
E : Type u_2
F : Type ?u.1651972
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hf : IntegrableOn f s
h't : ∀ᵐ (x : α) ∂μ, ¬x ∈ s → f x = 0
⊢ Integrable f

tactic: apply hf.of_ae_diff_eq_zero nullMeasurableSet_univ
state_before: α : Type u_1
β : Type ?u.1651966
E : Type u_2
F : Type ?u.1651972
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hf : IntegrableOn f s
h't : ∀ᵐ (x : α) ∂μ, ¬x ∈ s → f x = 0
⊢ IntegrableOn f univ

tactic: filter_upwards [h't]with x hx h'x using hx h'x.2
state_before: α : Type u_1
β : Type ?u.1651966
E : Type u_2
F : Type ?u.1651972
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hf : IntegrableOn f s
h't : ∀ᵐ (x : α) ∂μ, ¬x ∈ s → f x = 0
⊢ ∀ᵐ (x : α) ∂μ, x ∈ univ \ s → f x = 0
Theorem: List.get_append
File: Std/Data/List/Lemmas.lean

tactic: simp only [get, cons_append]
state_before: α : Type u_1
a : α
l x✝ : List α
n : Nat
h : n + 1 < length (a :: l)
⊢ get (a :: l ++ x✝) { val := n + 1, isLt := (_ : n + 1 < length (a :: l ++ x✝)) } =
    get (a :: l) { val := n + 1, isLt := h }

tactic: apply get_append
state_before: α : Type u_1
a : α
l x✝ : List α
n : Nat
h : n + 1 < length (a :: l)
⊢ get (List.append l x✝) { val := Nat.add n 0, isLt := (_ : succ (Nat.add n 0) ≤ length (List.append l x✝)) } =
    get l { val := Nat.add n 0, isLt := (_ : succ (Nat.add n 0) ≤ length l) }
Theorem: List.get?_append
File: Std/Data/List/Lemmas.lean

tactic: have hn' : n < (l₁ ++ l₂).length := Nat.lt_of_lt_of_le hn <|
  length_append .. ▸ Nat.le_add_right ..
state_before: α : Type u_1
l₁ l₂ : List α
n : Nat
hn : n < length l₁
⊢ get? (l₁ ++ l₂) n = get? l₁ n

tactic: rw [get?_eq_get hn, get?_eq_get hn', get_append]
state_before: α : Type u_1
l₁ l₂ : List α
n : Nat
hn : n < length l₁
hn' : n < length (l₁ ++ l₂)
⊢ get? (l₁ ++ l₂) n = get? l₁ n
Theorem: Asymptotics.IsEquivalent.tendsto_const
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rcases em <| c = 0 with rfl | h
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
⊢ Tendsto u l (𝓝 c)

tactic: exact (tendsto_congr' <| isEquivalent_zero_iff_eventually_zero.mp hu).mpr tendsto_const_nhds
state_before: case inl
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
hu : u ~[l] const α 0
⊢ Tendsto u l (𝓝 0)

tactic: exact (isEquivalent_const_iff_tendsto h).mp hu
state_before: case inr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
h : ¬c = 0
⊢ Tendsto u l (𝓝 c)
Theorem: List.tail_append_of_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: cases l
state_before: ι : Type ?u.45132
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l l' : List α
h : l ≠ []
⊢ tail (l ++ l') = tail l ++ l'

tactic: contradiction
state_before: case nil
ι : Type ?u.45132
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l' : List α
h : [] ≠ []
⊢ tail ([] ++ l') = tail [] ++ l'

tactic: simp
state_before: case cons
ι : Type ?u.45132
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l' : List α
head✝ : α
tail✝ : List α
h : head✝ :: tail✝ ≠ []
⊢ tail (head✝ :: tail✝ ++ l') = tail (head✝ :: tail✝) ++ l'
Theorem: UniqueFactorizationMonoid.dvdNotUnit_iff_normalizedFactors_lt_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: constructor
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ DvdNotUnit x y ↔ normalizedFactors x < normalizedFactors y

tactic: rintro ⟨_, c, hc, rfl⟩
state_before: case mp
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ DvdNotUnit x y → normalizedFactors x < normalizedFactors y

tactic: simp only [hx, right_ne_zero_of_mul hy, normalizedFactors_mul, Ne.def, not_false_iff,
  lt_add_iff_pos_right, normalizedFactors_pos, hc]
state_before: case mp.intro.intro.intro
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx left✝ : x ≠ 0
c : α
hc : ¬IsUnit c
hy : x * c ≠ 0
⊢ normalizedFactors x < normalizedFactors (x * c)

tactic: intro h
state_before: case mpr
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ normalizedFactors x < normalizedFactors y → DvdNotUnit x y

tactic: exact
  dvdNotUnit_of_dvd_of_not_dvd
    ((dvd_iff_normalizedFactors_le_normalizedFactors hx hy).mpr h.le)
    (mt (dvd_iff_normalizedFactors_le_normalizedFactors hy hx).mp h.not_le)
state_before: case mpr
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : normalizedFactors x < normalizedFactors y
⊢ DvdNotUnit x y
Theorem: Matrix.Pivot.mul_listTransvecRow_last_col
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: have A : (listTransvecRow M).length = r := by simp [listTransvecRow]
state_before: n : Type ?u.185522
p : Type ?u.185525
R : Type u₂
𝕜 : Type u_1
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
⊢ (M ⬝ List.prod (listTransvecRow M)) i (inr ()) = M i (inr ())

tactic: rw [← List.take_length (listTransvecRow M), A]
state_before: n : Type ?u.185522
p : Type ?u.185525
R : Type u₂
𝕜 : Type u_1
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
A : List.length (listTransvecRow M) = r
⊢ (M ⬝ List.prod (listTransvecRow M)) i (inr ()) = M i (inr ())

tactic: simpa using mul_listTransvecRow_last_col_take M i le_rfl
state_before: n : Type ?u.185522
p : Type ?u.185525
R : Type u₂
𝕜 : Type u_1
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
A : List.length (listTransvecRow M) = r
⊢ (M ⬝ List.prod (List.take r (listTransvecRow M))) i (inr ()) = M i (inr ())

tactic: simp [listTransvecRow]
state_before: n : Type ?u.185522
p : Type ?u.185525
R : Type u₂
𝕜 : Type u_1
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
⊢ List.length (listTransvecRow M) = r
Theorem: ENNReal.tendsto_const_mul_rpow_nhds_zero_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: convert ENNReal.Tendsto.const_mul (ENNReal.continuous_rpow_const.tendsto 0) _
state_before: c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ Tendsto (fun x => c * x ^ y) (𝓝 0) (𝓝 0)

tactic: simp [hy]
state_before: case h.e'_5.h.e'_3
c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ 0 = c * 0 ^ y

tactic: exact Or.inr hc
state_before: case convert_3
c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ 0 ^ y ≠ 0 ∨ c ≠ ⊤
Theorem: CategoryTheory.Limits.IsTerminal.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsTerminal X
f g : Y ⟶ X
⊢ ∀ (j : Discrete PEmpty), f ≫ (asEmptyCone X).π.app j = g ≫ (asEmptyCone X).π.app j
Theorem: CauSeq.zero_limZero
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa [abv_zero abv] using ε0
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
ε : α
ε0 : ε > 0
j : ℕ
x✝ : j ≥ 0
⊢ abv (↑0 j) < ε
Theorem: Rat.le_toNNRat_iff_coe_le'
File: Mathlib/Data/Rat/NNRat.lean

tactic: simp only [(hp.trans_le q.coe_nonneg).not_le, toNNRat_eq_zero.2 hp.le, hq.not_le]
state_before: p q✝ : ℚ
q : ℚ≥0
hq : 0 < q
hp : p < 0
⊢ q ≤ toNNRat p ↔ ↑q ≤ p
Theorem: Collinear.sbtw_of_dist_eq_of_dist_lt
File: Mathlib/Analysis/Convex/StrictConvexBetween.lean

tactic: refine' ⟨h.wbtw_of_dist_eq_of_dist_le hp₁ hp₂.le hp₃ hp₁p₃, _, _⟩
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : PseudoMetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : StrictConvexSpace ℝ V
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p < r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
⊢ Sbtw ℝ p₁ p₂ p₃

tactic: rintro rfl
state_before: case refine'_1
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : PseudoMetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : StrictConvexSpace ℝ V
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p < r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
⊢ p₂ ≠ p₁

tactic: exact hp₂.ne hp₁
state_before: case refine'_1
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : PseudoMetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : StrictConvexSpace ℝ V
p p₂ p₃ : P
r : ℝ
hp₂ : dist p₂ p < r
hp₃ : dist p₃ p = r
h : Collinear ℝ {p₂, p₂, p₃}
hp₁ : dist p₂ p = r
hp₁p₃ : p₂ ≠ p₃
⊢ False

tactic: rintro rfl
state_before: case refine'_2
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : PseudoMetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : StrictConvexSpace ℝ V
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p < r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
⊢ p₂ ≠ p₃

tactic: exact hp₂.ne hp₃
state_before: case refine'_2
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : PseudoMetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : StrictConvexSpace ℝ V
p p₁ p₂ : P
r : ℝ
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p < r
h : Collinear ℝ {p₁, p₂, p₂}
hp₃ : dist p₂ p = r
hp₁p₃ : p₁ ≠ p₂
⊢ False
Theorem: TopCat.Sheaf.extend_hom_app
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: nth_rw 2 [← (restrictHomEquivHom F F' h).left_inv α]
state_before: C : Type u
inst✝ : Category C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α : Functor.op (inducedFunctor B) ⋙ F ⟶ Functor.op (inducedFunctor B) ⋙ F'.val
i : ι
⊢ (↑(restrictHomEquivHom F F' h) α).app (B i).op = α.app i.op

tactic: rfl
state_before: C : Type u
inst✝ : Category C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α : Functor.op (inducedFunctor B) ⋙ F ⟶ Functor.op (inducedFunctor B) ⋙ F'.val
i : ι
⊢ (↑(restrictHomEquivHom F F' h) α).app (B i).op =
    (Equiv.invFun (restrictHomEquivHom F F' h) (Equiv.toFun (restrictHomEquivHom F F' h) α)).app i.op
Theorem: Multiset.fold_dedup_idem
File: Mathlib/Data/Multiset/Fold.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.19437
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
inst✝ : DecidableEq α
hi : IsIdempotent α op
s : Multiset α
b : α
⊢ fold op b (dedup 0) = fold op b 0

tactic: by_cases h : a ∈ s <;> simp [IH, h]
state_before: α : Type u_1
β : Type ?u.19437
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
inst✝ : DecidableEq α
hi : IsIdempotent α op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b (dedup s) = fold op b s
⊢ fold op b (dedup (a ::ₘ s)) = fold op b (a ::ₘ s)

tactic: show fold op b s = op a (fold op b s)
state_before: case pos
α : Type u_1
β : Type ?u.19437
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
inst✝ : DecidableEq α
hi : IsIdempotent α op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b (dedup s) = fold op b s
h : a ∈ s
⊢ fold op b s = op a (fold op b s)

tactic: rw [← cons_erase h, fold_cons_left, ← ha.assoc, hi.idempotent]
state_before: case pos
α : Type u_1
β : Type ?u.19437
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
inst✝ : DecidableEq α
hi : IsIdempotent α op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b (dedup s) = fold op b s
h : a ∈ s
⊢ fold op b s = op a (fold op b s)
Theorem: Finset.biUnion_filter_eq_of_maps_to
File: Mathlib/Data/Finset/Basic.lean

tactic: simpa only [disjiUnion_eq_biUnion] using disjiUnion_filter_eq_of_maps_to h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.521487
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq α
s : Finset α
t : Finset β
f : α → β
h : ∀ (x : α), x ∈ s → f x ∈ t
⊢ (Finset.biUnion t fun a => filter (fun c => f c = a) s) = s
Theorem: Lean.Data.AC.List.two_step_induction
File: src/lean/Init/Data/AC.lean

tactic: induction l with
| nil => assumption
| cons a l => cases l; apply single; apply step; assumption
state_before: motive : List Nat → Sort u
l : List Nat
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
⊢ motive l

tactic: assumption
state_before: case nil
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
⊢ motive []

tactic: cases l
state_before: case cons
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
a : Nat
l : List Nat
tail_ih✝ : motive l
⊢ motive (a :: l)

tactic: apply single
state_before: case cons.nil
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
a : Nat
tail_ih✝ : motive []
⊢ motive [a]

case cons.cons
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
a head✝ : Nat
tail✝ : List Nat
tail_ih✝ : motive (head✝ :: tail✝)
⊢ motive (a :: head✝ :: tail✝)

tactic: apply step
state_before: case cons.cons
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
a head✝ : Nat
tail✝ : List Nat
tail_ih✝ : motive (head✝ :: tail✝)
⊢ motive (a :: head✝ :: tail✝)

tactic: assumption
state_before: case cons.cons.a
motive : List Nat → Sort u
empty : motive []
single : (a : Nat) → motive [a]
step : (a b : Nat) → (l : List Nat) → motive (b :: l) → motive (a :: b :: l)
a head✝ : Nat
tail✝ : List Nat
tail_ih✝ : motive (head✝ :: tail✝)
⊢ motive (head✝ :: tail✝)
Theorem: PGame.Subsequent.moveLeft_mk_left
File: Mathlib/SetTheory/Game/PGame.lean

tactic: pgame_wf_tac
state_before: xl : Type u_1
i : xl
xr : Type u_1
xR : xr → PGame
xL : xl → PGame
j : LeftMoves (xL i)
⊢ Subsequent (PGame.moveLeft (xL i) j) (mk xl xr xL xR)
Theorem: mul_dvd_mul
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝ : CommSemigroup α
a✝ b c✝ a c e f : α
⊢ a * e * (c * f) = a * c * (e * f)
Theorem: Commute.one_div_add_one_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [(Commute.one_right a).div_add_div hab ha hb, one_mul, mul_one, add_comm]
state_before: α : Type u_1
β : Type ?u.14282
K : Type ?u.14285
inst✝ : DivisionSemiring α
a b c d : α
hab : _root_.Commute a b
ha : a ≠ 0
hb : b ≠ 0
⊢ 1 / a + 1 / b = (a + b) / (a * b)
Theorem: intervalIntegral.smul_integral_comp_mul_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_sub]
state_before: ι : Type ?u.14916038
𝕜 : Type ?u.14916041
E : Type u_1
F : Type ?u.14916047
A : Type ?u.14916050
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ (c • ∫ (x : ℝ) in a..b, f (c * x - d)) = ∫ (x : ℝ) in c * a - d..c * b - d, f x
Theorem: Equiv.exists_unique_congr_left'
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
f : α ≃ β
x✝ : α
⊢ p x✝ ↔ p (↑f.symm (↑f x✝))