tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.map_preimage
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [coe_range, sep_mem_eq, coe_map, Finset.coe_filter,
  ← mem_preimage, inter_comm, preimage_inter_range, ← Finset.mem_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.58114
inst✝ : MeasurableSpace α
f : α →ₛ β
g : β → γ
s : Set γ
⊢ ↑(map g f) ⁻¹' s = ↑f ⁻¹' ↑(Finset.filter (fun b => g b ∈ s) (SimpleFunc.range f))

tactic: exact preimage_comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.58114
inst✝ : MeasurableSpace α
f : α →ₛ β
g : β → γ
s : Set γ
⊢ g ∘ ↑f ⁻¹' s = ↑f ⁻¹' (g ⁻¹' s)
Theorem: Ordinal.principal_mul_iff_le_two_or_omega_opow_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' ⟨fun ho => _, _⟩
state_before: o : Ordinal
⊢ Principal (fun x x_1 => x * x_1) o ↔ o ≤ 2 ∨ ∃ a, o = ω ^ ω ^ a

tactic: cases' le_or_lt o 2 with ho₂ ho₂
state_before: case refine'_1
o : Ordinal
ho : Principal (fun x x_1 => x * x_1) o
⊢ o ≤ 2 ∨ ∃ a, o = ω ^ ω ^ a

tactic: rcases principal_add_iff_zero_or_omega_opow.1 (principal_add_of_principal_mul ho ho₂.ne') with
  (rfl | ⟨a, rfl⟩)
state_before: case refine'_1.inr
o : Ordinal
ho : Principal (fun x x_1 => x * x_1) o
ho₂ : 2 < o
⊢ o ≤ 2 ∨ ∃ a, o = ω ^ ω ^ a

tactic: rcases principal_add_iff_zero_or_omega_opow.1
    (principal_add_of_principal_mul_opow one_lt_omega ho) with
  (rfl | ⟨b, rfl⟩)
state_before: case refine'_1.inr.inr.intro
a : Ordinal
ho : Principal (fun x x_1 => x * x_1) (ω ^ a)
ho₂ : 2 < ω ^ a
⊢ ω ^ a ≤ 2 ∨ ∃ a_1, ω ^ a = ω ^ ω ^ a_1

tactic: exact Or.inr ⟨b, rfl⟩
state_before: case refine'_1.inr.inr.intro.inr.intro
b : Ordinal
ho : Principal (fun x x_1 => x * x_1) (ω ^ ω ^ b)
ho₂ : 2 < ω ^ ω ^ b
⊢ ω ^ ω ^ b ≤ 2 ∨ ∃ a, ω ^ ω ^ b = ω ^ ω ^ a

tactic: exact Or.inl ho₂
state_before: case refine'_1.inl
o : Ordinal
ho : Principal (fun x x_1 => x * x_1) o
ho₂ : o ≤ 2
⊢ o ≤ 2 ∨ ∃ a, o = ω ^ ω ^ a

tactic: exact (Ordinal.not_lt_zero 2 ho₂).elim
state_before: case refine'_1.inr.inl
ho : Principal (fun x x_1 => x * x_1) 0
ho₂ : 2 < 0
⊢ 0 ≤ 2 ∨ ∃ a, 0 = ω ^ ω ^ a

tactic: left
state_before: case refine'_1.inr.inr.intro.inl
ho : Principal (fun x x_1 => x * x_1) (ω ^ 0)
ho₂ : 2 < ω ^ 0
⊢ ω ^ 0 ≤ 2 ∨ ∃ a, ω ^ 0 = ω ^ ω ^ a

tactic: simpa using one_le_two
state_before: case refine'_1.inr.inr.intro.inl.h
ho : Principal (fun x x_1 => x * x_1) (ω ^ 0)
ho₂ : 2 < ω ^ 0
⊢ ω ^ 0 ≤ 2

tactic: rintro (ho₂ | ⟨a, rfl⟩)
state_before: case refine'_2
o : Ordinal
⊢ (o ≤ 2 ∨ ∃ a, o = ω ^ ω ^ a) → Principal (fun x x_1 => x * x_1) o

tactic: exact principal_mul_of_le_two ho₂
state_before: case refine'_2.inl
o : Ordinal
ho₂ : o ≤ 2
⊢ Principal (fun x x_1 => x * x_1) o

tactic: exact principal_mul_omega_opow_opow a
state_before: case refine'_2.inr.intro
a : Ordinal
⊢ Principal (fun x x_1 => x * x_1) (ω ^ ω ^ a)
Theorem: Filter.frequently_or_distrib_left
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.164287
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∃ᶠ (x : α) in f, q x
Theorem: NormedCommGroup.tendsto_nhds_nhds
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp_rw [Metric.tendsto_nhds_nhds, dist_eq_norm_div]
state_before: 𝓕 : Type ?u.108981
𝕜 : Type ?u.108984
α : Type ?u.108987
ι : Type ?u.108990
κ : Type ?u.108993
E : Type u_1
F : Type u_2
G : Type ?u.109002
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : E → F
x : E
y : F
⊢ Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ (ε : ℝ), ε > 0 → ∃ δ, δ > 0 ∧ ∀ (x' : E), ‖x' / x‖ < δ → ‖f x' / y‖ < ε
Theorem: Int.testBit_lor
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_or, testBit_bitwise]
state_before: m n : ℤ
k : ℕ
⊢ testBit (lor m n) k = (testBit m k || testBit n k)
Theorem: Cardinal.iSup_lt_lift_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type ?u.160553
r : α → α → Prop
ι : Type u
f : ι → Cardinal
c : Cardinal
hc : IsRegular c
hι : lift (#ι) < c
⊢ lift (#ι) < Ordinal.cof (ord c)
Theorem: Isometry.ediam_image
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [EMetric.diam_le_iff, ball_image_iff, hf.edist_eq]
state_before: ι : Type ?u.44257
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x y z : α
s✝ : Set α
hf : Isometry f
s : Set α
d : ℝ≥0∞
⊢ EMetric.diam (f '' s) ≤ d ↔ EMetric.diam s ≤ d
Theorem: List.mem_cyclicPermutations_iff
File: Mathlib/Data/List/Rotate.lean

tactic: constructor
state_before: α : Type u
l✝ l'✝ l l' : List α
⊢ l ∈ cyclicPermutations l' ↔ l ~r l'

tactic: intro h
state_before: case mp
α : Type u
l✝ l'✝ l l' : List α
⊢ l ∈ cyclicPermutations l' → l ~r l'

tactic: obtain ⟨k, hk, rfl⟩ := nthLe_of_mem h
state_before: case mp
α : Type u
l✝ l'✝ l l' : List α
h : l ∈ cyclicPermutations l'
⊢ l ~r l'

tactic: simp
state_before: case mp.intro.intro
α : Type u
l l'✝ l' : List α
k : ℕ
hk : k < length (cyclicPermutations l')
h : nthLe (cyclicPermutations l') k hk ∈ cyclicPermutations l'
⊢ nthLe (cyclicPermutations l') k hk ~r l'

tactic: intro h
state_before: case mpr
α : Type u
l✝ l'✝ l l' : List α
⊢ l ~r l' → l ∈ cyclicPermutations l'

tactic: obtain ⟨k, rfl⟩ := h.symm
state_before: case mpr
α : Type u
l✝ l'✝ l l' : List α
h : l ~r l'
⊢ l ∈ cyclicPermutations l'

tactic: rw [mem_iff_nthLe]
state_before: case mpr.intro
α : Type u
l l'✝ l' : List α
k : ℕ
h : rotate l' k ~r l'
⊢ rotate l' k ∈ cyclicPermutations l'

tactic: simp only [exists_prop, nthLe_cyclicPermutations]
state_before: case mpr.intro
α : Type u
l l'✝ l' : List α
k : ℕ
h : rotate l' k ~r l'
⊢ ∃ n h, nthLe (cyclicPermutations l') n h = rotate l' k

tactic: cases' l' with x l
state_before: case mpr.intro
α : Type u
l l'✝ l' : List α
k : ℕ
h : rotate l' k ~r l'
⊢ ∃ n, n < length (cyclicPermutations l') ∧ rotate l' n = rotate l' k

tactic: simp
state_before: case mpr.intro.nil
α : Type u
l l' : List α
k : ℕ
h : rotate [] k ~r []
⊢ ∃ n, n < length (cyclicPermutations []) ∧ rotate [] n = rotate [] k

tactic: refine' ⟨k % length (x :: l), _, rotate_mod _ _⟩
state_before: case mpr.intro.cons
α : Type u
l✝ l' : List α
k : ℕ
x : α
l : List α
h : rotate (x :: l) k ~r (x :: l)
⊢ ∃ n, n < length (cyclicPermutations (x :: l)) ∧ rotate (x :: l) n = rotate (x :: l) k

tactic: simpa using Nat.mod_lt _ (zero_lt_succ _)
state_before: case mpr.intro.cons
α : Type u
l✝ l' : List α
k : ℕ
x : α
l : List α
h : rotate (x :: l) k ~r (x :: l)
⊢ k % length (x :: l) < length (cyclicPermutations (x :: l))
Theorem: Stirling.tendsto_stirlingSeq_sqrt_pi
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: obtain ⟨a, hapos, halimit⟩ := stirlingSeq_has_pos_limit_a
state_before: ⊢ Tendsto (fun n => stirlingSeq n) atTop (𝓝 (Real.sqrt π))

tactic: have hπ : π / 2 = a ^ 2 / 2 :=
  tendsto_nhds_unique Wallis.tendsto_W_nhds_pi_div_two (second_wallis_limit a hapos.ne' halimit)
state_before: case intro.intro
a : ℝ
hapos : 0 < a
halimit : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto (fun n => stirlingSeq n) atTop (𝓝 (Real.sqrt π))

tactic: rwa [(div_left_inj' (two_ne_zero' ℝ)).mp hπ, sqrt_sq hapos.le]
state_before: case intro.intro
a : ℝ
hapos : 0 < a
halimit : Tendsto stirlingSeq atTop (𝓝 a)
hπ : π / ↑2 = a ^ 2 / 2
⊢ Tendsto (fun n => stirlingSeq n) atTop (𝓝 (Real.sqrt π))
Theorem: Turing.ListBlank.cons_head_tail
File: Mathlib/Computability/TuringMachine.lean

tactic: apply Quotient.ind'
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (l : ListBlank Γ), cons (head l) (tail l) = l

tactic: refine' fun l ↦ Quotient.sound' (Or.inr _)
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (a : List Γ), cons (head (Quotient.mk'' a)) (tail (Quotient.mk'' a)) = Quotient.mk'' a

tactic: cases l
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
⊢ BlankExtends l (head (Quotient.mk'' l) :: List.tail l)

tactic: exact ⟨1, rfl⟩
state_before: case h.nil
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ BlankExtends [] (head (Quotient.mk'' []) :: List.tail [])

tactic: rfl
state_before: case h.cons
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
tail✝ : List Γ
⊢ BlankExtends (head✝ :: tail✝) (head (Quotient.mk'' (head✝ :: tail✝)) :: List.tail (head✝ :: tail✝))
Theorem: ProbabilityTheory.kernel.piecewise_apply'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [piecewise_apply]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1459789
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
t : Set β
⊢ ↑↑(↑(piecewise hs κ η) a) t = if a ∈ s then ↑↑(↑κ a) t else ↑↑(↑η a) t

tactic: split_ifs <;> rfl
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1459789
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
t : Set β
⊢ ↑↑(if a ∈ s then ↑κ a else ↑η a) t = if a ∈ s then ↑↑(↑κ a) t else ↑↑(↑η a) t
Theorem: Function.Periodic.int_mul
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [zsmul_eq_mul] using h.zsmul n
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.105416
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℤ
⊢ Periodic f (↑n * c)
Theorem: geom_sum_pos'
File: Mathlib/Algebra/GeomSum.lean

tactic: obtain _ | _ | n := n
state_before: α : Type u
β : Type ?u.241921
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
hn : n ≠ 0
⊢ 0 < ∑ i in range n, x ^ i

tactic: obtain hx' | hx' := lt_or_le x 0
state_before: case succ.succ
α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
⊢ 0 < ∑ i in range (Nat.succ (Nat.succ n)), x ^ i

tactic: cases hn rfl
state_before: case zero
α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
hn : Nat.zero ≠ 0
⊢ 0 < ∑ i in range Nat.zero, x ^ i

tactic: simp only [Nat.zero_eq, ← Nat.one_eq_succ_zero, range_one, sum_singleton, pow_zero, zero_lt_one]
state_before: case succ.zero
α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
hn : Nat.succ Nat.zero ≠ 0
⊢ 0 < ∑ i in range (Nat.succ Nat.zero), x ^ i

tactic: exact (geom_sum_pos_and_lt_one hx' hx n.one_lt_succ_succ).1
state_before: case succ.succ.inl
α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
hx' : x < 0
⊢ 0 < ∑ i in range (Nat.succ (Nat.succ n)), x ^ i

tactic: exact geom_sum_pos hx' (by simp only [Nat.succ_ne_zero, Ne.def, not_false_iff])
state_before: case succ.succ.inr
α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
hx' : 0 ≤ x
⊢ 0 < ∑ i in range (Nat.succ (Nat.succ n)), x ^ i

tactic: simp only [Nat.succ_ne_zero, Ne.def, not_false_iff]
state_before: α : Type u
β : Type ?u.241921
x : α
inst✝ : LinearOrderedRing α
hx : 0 < x + 1
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
hx' : 0 ≤ x
⊢ Nat.succ (Nat.succ n) ≠ 0
Theorem: Std.PairingHeapImp.Heap.size_merge
File: Std/Data/PairingHeap.lean

tactic: match h₁, h₂ with
| .nil, .nil | .nil, .node _ _ | .node _ _, .nil => simp [size]
| .node _ _, .node _ _ => unfold merge; dsimp; split <;> simp_arith [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : NoSibling s₁
h₂ : NoSibling s₂
⊢ size (merge le s₁ s₂) = size s₁ + size s₂

tactic: simp [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : NoSibling s₁
h₂ : NoSibling s₂
a✝ : α
c✝ : Heap α
⊢ size (merge le (node a✝ c✝ nil) nil) = size (node a✝ c✝ nil) + size nil

tactic: unfold merge
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : NoSibling s₁
h₂ : NoSibling s₂
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ size (merge le (node a✝¹ c✝¹ nil) (node a✝ c✝ nil)) = size (node a✝¹ c✝¹ nil) + size (node a✝ c✝ nil)

tactic: dsimp
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : NoSibling s₁
h₂ : NoSibling s₂
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ size
      (match node a✝¹ c✝¹ nil, node a✝ c✝ nil with
      | nil, nil => nil
      | nil, node a₂ c₂ sibling => node a₂ c₂ nil
      | node a₁ c₁ sibling, nil => node a₁ c₁ nil
      | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>
        if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) nil) =
    size (node a✝¹ c✝¹ nil) + size (node a✝ c✝ nil)

tactic: split <;> simp_arith [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : NoSibling s₁
h₂ : NoSibling s₂
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ size (if le a✝¹ a✝ = true then node a✝¹ (node a✝ c✝ c✝¹) nil else node a✝ (node a✝¹ c✝¹ c✝) nil) =
    size (node a✝¹ c✝¹ nil) + size (node a✝ c✝ nil)
Theorem: Real.sinh_add_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [add_comm, cosh_add_sinh]
state_before: x y : ℝ
⊢ sinh x + cosh x = exp x
Theorem: Nat.mem_divisorsAntidiagonal
File: Mathlib/NumberTheory/Divisors.lean

tactic: simp only [divisorsAntidiagonal, Finset.mem_Ico, Ne.def, Finset.mem_filter, Finset.mem_product]
state_before: n : ℕ
x : ℕ × ℕ
⊢ x ∈ divisorsAntidiagonal n ↔ x.fst * x.snd = n ∧ n ≠ 0

tactic: rw [and_comm]
state_before: n : ℕ
x : ℕ × ℕ
⊢ ((1 ≤ x.fst ∧ x.fst < n + 1) ∧ 1 ≤ x.snd ∧ x.snd < n + 1) ∧ x.fst * x.snd = n ↔ x.fst * x.snd = n ∧ ¬n = 0

tactic: apply and_congr_right
state_before: n : ℕ
x : ℕ × ℕ
⊢ x.fst * x.snd = n ∧ (1 ≤ x.fst ∧ x.fst < n + 1) ∧ 1 ≤ x.snd ∧ x.snd < n + 1 ↔ x.fst * x.snd = n ∧ ¬n = 0

tactic: rintro rfl
state_before: case h
n : ℕ
x : ℕ × ℕ
⊢ x.fst * x.snd = n → ((1 ≤ x.fst ∧ x.fst < n + 1) ∧ 1 ≤ x.snd ∧ x.snd < n + 1 ↔ ¬n = 0)

tactic: constructor <;> intro h
state_before: case h
x : ℕ × ℕ
⊢ (1 ≤ x.fst ∧ x.fst < x.fst * x.snd + 1) ∧ 1 ≤ x.snd ∧ x.snd < x.fst * x.snd + 1 ↔ ¬x.fst * x.snd = 0

tactic: contrapose! h
state_before: case h.mp
x : ℕ × ℕ
h : (1 ≤ x.fst ∧ x.fst < x.fst * x.snd + 1) ∧ 1 ≤ x.snd ∧ x.snd < x.fst * x.snd + 1
⊢ ¬x.fst * x.snd = 0

tactic: simp [h]
state_before: case h.mp
x : ℕ × ℕ
h : x.fst * x.snd = 0
⊢ 1 ≤ x.fst ∧ x.fst < x.fst * x.snd + 1 → 1 ≤ x.snd → x.fst * x.snd + 1 ≤ x.snd

tactic: rw [Nat.lt_add_one_iff, Nat.lt_add_one_iff]
state_before: case h.mpr
x : ℕ × ℕ
h : ¬x.fst * x.snd = 0
⊢ (1 ≤ x.fst ∧ x.fst < x.fst * x.snd + 1) ∧ 1 ≤ x.snd ∧ x.snd < x.fst * x.snd + 1

tactic: rw [mul_eq_zero, not_or] at h
state_before: case h.mpr
x : ℕ × ℕ
h : ¬x.fst * x.snd = 0
⊢ (1 ≤ x.fst ∧ x.fst ≤ x.fst * x.snd) ∧ 1 ≤ x.snd ∧ x.snd ≤ x.fst * x.snd

tactic: simp only [succ_le_of_lt (Nat.pos_of_ne_zero h.1), succ_le_of_lt (Nat.pos_of_ne_zero h.2),
  true_and_iff]
state_before: case h.mpr
x : ℕ × ℕ
h : ¬x.fst = 0 ∧ ¬x.snd = 0
⊢ (1 ≤ x.fst ∧ x.fst ≤ x.fst * x.snd) ∧ 1 ≤ x.snd ∧ x.snd ≤ x.fst * x.snd

tactic: exact
  ⟨le_mul_of_pos_right (Nat.pos_of_ne_zero h.2), le_mul_of_pos_left (Nat.pos_of_ne_zero h.1)⟩
state_before: case h.mpr
x : ℕ × ℕ
h : ¬x.fst = 0 ∧ ¬x.snd = 0
⊢ x.fst ≤ x.fst * x.snd ∧ x.snd ≤ x.fst * x.snd
Theorem: Polynomial.cyclotomic_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: have hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ := by
  simp only [cyclotomic'_one, PNat.one_coe, map_X, Polynomial.map_one, Polynomial.map_sub]
state_before: R : Type u_1
inst✝ : Ring R
⊢ cyclotomic 1 R = X - 1

tactic: symm
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ cyclotomic 1 R = X - 1

tactic: rw [← map_cyclotomic_int, ← int_cyclotomic_unique hspec]
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = cyclotomic 1 R

tactic: simp only [map_X, Polynomial.map_one, Polynomial.map_sub]
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = map (Int.castRingHom R) (X - 1)

tactic: simp only [cyclotomic'_one, PNat.one_coe, map_X, Polynomial.map_one, Polynomial.map_sub]
state_before: R : Type u_1
inst✝ : Ring R
⊢ map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
Theorem: Real.logb_le_iff_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_le_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hx]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b x ≤ y ↔ x ≤ b ^ y
Theorem: Filter.isCobounded_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp (config := { contextual := true }) [IsCobounded, eq_univ_iff_forall,
  exists_true_iff_nonempty]
state_before: α : Type u_1
β : Type ?u.20125
γ : Type ?u.20128
ι : Type ?u.20131
r : α → α → Prop
f g : Filter α
⊢ IsCobounded r ⊤ ↔ Nonempty α
Theorem: CategoryTheory.preserves_desc_mapCocone
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: simp [← G.map_comp]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
G : C ⥤ D
J : Type w
inst✝¹ : Category J
F : J ⥤ C
inst✝ : PreservesColimit F G
c₁ c₂ : Cocone F
t : IsColimit c₁
⊢ ∀ (j : J), (G.mapCocone c₁).ι.app j ≫ G.map (IsColimit.desc t c₂) = (G.mapCocone c₂).ι.app j
Theorem: Multiset.pow_count
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [filter_eq, prod_replicate]
state_before: ι : Type ?u.36621
α : Type u_1
β : Type ?u.36627
γ : Type ?u.36630
inst✝¹ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
a : α
⊢ a ^ count a s = prod (filter (Eq a) s)
Theorem: lipschitzOnWith_iff_norm_div_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [lipschitzOnWith_iff_dist_le_mul, dist_eq_norm_div]
state_before: 𝓕 : Type ?u.185016
𝕜 : Type ?u.185019
α : Type ?u.185022
ι : Type ?u.185025
κ : Type ?u.185028
E : Type u_1
F : Type u_2
G : Type ?u.185037
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : E → F
C : ℝ≥0
⊢ LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x / f y‖ ≤ ↑C * ‖x / y‖
Theorem: IsBezout.dvd_gcd
File: Mathlib/RingTheory/Bezout.lean

tactic: rw [← Ideal.span_singleton_le_span_singleton] at hx hy ⊢
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsBezout R
x y z : R
hx : z ∣ x
hy : z ∣ y
⊢ z ∣ gcd x y

tactic: rw [span_gcd, Ideal.span_insert, sup_le_iff]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsBezout R
x y z : R
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {gcd x y} ≤ Ideal.span {z}

tactic: exact ⟨hx, hy⟩
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsBezout R
x y z : R
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {x} ≤ Ideal.span {z} ∧ Ideal.span {y} ≤ Ideal.span {z}
Theorem: MeasureTheory.Measure.comap_preimage
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comap_apply₀ _ _ hf h (hf' hs).nullMeasurableSet, image_preimage_eq_inter_range]
state_before: α : Type u_2
β✝ : Type ?u.252454
γ : Type ?u.252457
δ : Type ?u.252460
ι : Type ?u.252463
R : Type ?u.252466
R' : Type ?u.252469
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
s : Set β
hf : Injective f
hf' : Measurable f
h : ∀ (t : Set α), MeasurableSet t → NullMeasurableSet (f '' t)
hs : MeasurableSet s
⊢ ↑↑(comap f μ) (f ⁻¹' s) = ↑↑μ (s ∩ range f)
Theorem: SimpleGraph.edgeSet_fromEdgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext e
state_before: ι : Sort ?u.80342
𝕜 : Type ?u.80345
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ edgeSet (fromEdgeSet s) = s \ {e | Sym2.IsDiag e}

tactic: exact Sym2.ind (by simp) e
state_before: case h
ι : Sort ?u.80342
𝕜 : Type ?u.80345
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ edgeSet (fromEdgeSet s) ↔ e ∈ s \ {e | Sym2.IsDiag e}

tactic: simp
state_before: ι : Sort ?u.80342
𝕜 : Type ?u.80345
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ ∀ (x y : V),
    Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet (fromEdgeSet s) ↔
      Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ s \ {e | Sym2.IsDiag e}
Theorem: Unitization.inr_mul_inl
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: rw [smul_zero, zero_add, MulZeroClass.mul_zero, add_zero]
state_before: R : Type u_1
A : Type u_2
inst✝² : Semiring R
inst✝¹ : NonUnitalNonAssocSemiring A
inst✝ : DistribMulAction R A
r : R
a : A
⊢ 0 • 0 + r • a + a * 0 = r • a
Theorem: CauSeq.Completion.cau_seq_zero_ne_one
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: simpa
state_before: α : Type u_2
inst✝² : LinearOrderedField α
β : Type u_1
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
h : 0 ≈ 1
this : LimZero (1 - 0)
⊢ LimZero 1

tactic: apply one_ne_zero <| const_limZero.1 this
state_before: α : Type u_2
inst✝² : LinearOrderedField α
β : Type u_1
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
h : 0 ≈ 1
this✝ : LimZero (1 - 0)
this : LimZero 1
⊢ False
Theorem: dite_dite_distrib_right
File: Mathlib/Logic/Lemmas.lean

tactic: split_ifs <;> rfl
state_before: α : Sort u_1
p q r : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
a✝ b✝ c✝ : α
a : p → q → α
b : p → ¬q → α
c : ¬p → α
⊢ dite p (fun hp => dite q (a hp) (b hp)) c =
    if hq : q then dite p (fun hp => a hp hq) c else dite p (fun hp => b hp hq) c
Theorem: Finsupp.toMultiset_sum_single
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: simp_rw [toMultiset_sum, Finsupp.toMultiset_single, sum_nsmul, sum_multiset_singleton]
state_before: α : Type ?u.13830
β : Type ?u.13833
ι : Type u_1
s : Finset ι
n : ℕ
⊢ ↑toMultiset (∑ i in s, single i n) = n • s.val
Theorem: Matrix.row_vecMul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1214702
m : Type u_1
n : Type u_2
o : Type ?u.1214711
m' : o → Type ?u.1214716
n' : o → Type ?u.1214721
R : Type ?u.1214724
S : Type ?u.1214727
α : Type v
β : Type w
γ : Type ?u.1214734
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : m → α
⊢ row (vecMul v M) = row v ⬝ M

tactic: rfl
state_before: case a.h
l : Type ?u.1214702
m : Type u_1
n : Type u_2
o : Type ?u.1214711
m' : o → Type ?u.1214716
n' : o → Type ?u.1214721
R : Type ?u.1214724
S : Type ?u.1214727
α : Type v
β : Type w
γ : Type ?u.1214734
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : m → α
i✝ : Unit
x✝ : n
⊢ row (vecMul v M) i✝ x✝ = (row v ⬝ M) i✝ x✝
Theorem: Ordinal.opow_le_of_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [opow_limit a0 h, bsup_le_iff]
state_before: a b c : Ordinal
a0 : a ≠ 0
h : IsLimit b
⊢ a ^ b ≤ c ↔ ∀ (b' : Ordinal), b' < b → a ^ b' ≤ c
Theorem: Filter.tendsto_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, le_principal_iff, mem_map', Filter.Eventually]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.317172
ι : Sort x
f : α → β
l : Filter α
s : Set β
⊢ Tendsto f l (𝓟 s) ↔ ∀ᶠ (a : α) in l, f a ∈ s
Theorem: ENNReal.div_lt_of_lt_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rwa [div_eq_mul_inv, inv_inv]
state_before: α : Type ?u.293310
β : Type ?u.293313
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a < b * c
⊢ a < b / c⁻¹
Theorem: nhds_top_order
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [nhds_eq_order (⊤ : α)]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : Preorder α
inst✝¹ : OrderTop α
inst✝ : OrderTopology α
⊢ 𝓝 ⊤ = ⨅ (l : α) (_ : l < ⊤), 𝓟 (Ioi l)
Theorem: List.rotate_zero
File: Mathlib/Data/List/Rotate.lean

tactic: simp [rotate]
state_before: α : Type u
l : List α
⊢ rotate l 0 = l
Theorem: List.nil_zipWith
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.144286
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → γ
l : List β
⊢ zipWith f [] l = []
Theorem: Stream'.mem_interleave_left
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, nth_interleave_left]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s₁ s₂ : Stream' α
x✝ : a ∈ s₁
n : ℕ
h : (fun b => a = b) (nth s₁ n)
⊢ (fun b => a = b) (nth (s₁ ⋈ s₂) (2 * n))