tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Functor.eventualRange_eq_iff
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: rw [subset_antisymm_iff, eventualRange, and_iff_right (iInter₂_subset _ _), subset_iInter₂_iff]
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
⊢ eventualRange F j = range (F.map f) ↔ ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))

tactic: refine' ⟨fun h k g => h _ _, fun h j' f' => _⟩
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
⊢ (∀ (i_1 : J) (j_1 : i_1 ⟶ j), range (F.map f) ⊆ range (F.map j_1)) ↔
    ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))

tactic: obtain ⟨k, g, g', he⟩ := cospan f f'
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
h : ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
j' : J
f' : j' ⟶ j
⊢ range (F.map f) ⊆ range (F.map f')

tactic: refine' (h g).trans _
state_before: case intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
h : ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
j' : J
f' : j' ⟶ j
k : J
g : k ⟶ i
g' : k ⟶ j'
he : g ≫ f = g' ≫ f'
⊢ range (F.map f) ⊆ range (F.map f')

tactic: rw [he, F.map_comp]
state_before: case intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
h : ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
j' : J
f' : j' ⟶ j
k : J
g : k ⟶ i
g' : k ⟶ j'
he : g ≫ f = g' ≫ f'
⊢ range (F.map (g ≫ f)) ⊆ range (F.map f')

tactic: apply range_comp_subset_range
state_before: case intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : i ⟶ j
h : ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
j' : J
f' : j' ⟶ j
k : J
g : k ⟶ i
g' : k ⟶ j'
he : g ≫ f = g' ≫ f'
⊢ range (F.map g' ≫ F.map f') ⊆ range (F.map f')
Theorem: List.Perm.diff_right
File: Mathlib/Data/List/Perm.lean

tactic: induction t generalizing l₁ l₂ h <;> simp [*, Perm.erase]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t : List α
h : l₁ ~ l₂
⊢ List.diff l₁ t ~ List.diff l₂ t
Theorem: Multiset.count_sum'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: dsimp only [Finset.sum]
state_before: ι : Type ?u.936144
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : DecidableEq α
s : Finset β
a : α
f : β → Multiset α
⊢ count a (∑ x in s, f x) = ∑ x in s, count a (f x)

tactic: rw [count_sum]
state_before: ι : Type ?u.936144
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : DecidableEq α
s : Finset β
a : α
f : β → Multiset α
⊢ count a (sum (map (fun x => f x) s.val)) = sum (map (fun x => count a (f x)) s.val)
Theorem: Finset.empty_union
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.148810
γ : Type ?u.148813
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x : α
⊢ x ∈ ∅ ∨ x ∈ s ↔ x ∈ s
Theorem: Matrix.vecMul_stdBasis
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
  simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
state_before: R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
⊢ vecMul (↑(LinearMap.stdBasis R (fun x => R) i) 1) M j = M i j

tactic: simp only [vecMul, dotProduct]
state_before: R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ vecMul (↑(LinearMap.stdBasis R (fun x => R) i) 1) M j = M i j

tactic: convert this
state_before: R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ∑ x : m, ↑(LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j

tactic: split_ifs with h <;> simp only [stdBasis_apply]
state_before: case h.e'_2.a.h.e'_5
R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
⊢ ↑(LinearMap.stdBasis R (fun x => R) i) 1 x✝ = if i = x✝ then 1 else 0

tactic: simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
state_before: R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
⊢ ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j

tactic: rw [h, Function.update_same]
state_before: case h.e'_2.a.h.e'_5.inl
R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : i = x✝
⊢ Function.update 0 i 1 x✝ = 1

tactic: rw [Function.update_noteq (Ne.symm h), Pi.zero_apply]
state_before: case h.e'_2.a.h.e'_5.inr
R : Type u_3
inst✝² : Semiring R
l : Type ?u.4510
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : ¬i = x✝
⊢ Function.update 0 i 1 x✝ = 0
Theorem: mul_div_cancel'''
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_inv_mul, inv_mul_cancel_left]
state_before: α : Type ?u.71563
β : Type ?u.71566
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c d a b : G
⊢ a * b / a = b
Theorem: MvPolynomial.degreeOf_zero
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical simp only [degreeOf_def, degrees_zero, Multiset.count_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.285420
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
⊢ degreeOf n 0 = 0

tactic: simp only [degreeOf_def, degrees_zero, Multiset.count_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.285420
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
⊢ degreeOf n 0 = 0
Theorem: ProjectiveSpectrum.basicOpen_mul_le_right
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [basicOpen_mul 𝒜 f g]
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 g

tactic: exact inf_le_right
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 g
Theorem: Cardinal.ord_one
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using ord_nat 1
state_before: α : Type ?u.228585
β : Type ?u.228588
γ : Type ?u.228591
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ord 1 = 1
Theorem: Cardinal.ord_card_unbounded
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: dsimp
state_before: a : Ordinal
⊢ ord (succ (card a)) ∈ {b | ord (card b) = b}

tactic: rw [card_ord]
state_before: a : Ordinal
⊢ ord (card (ord (succ (card a)))) = ord (succ (card a))
Theorem: SimpleGraph.Walk.map_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u✝ v✝ u' v' : V
p✝ : Walk G u✝ v✝
u v w : V
p : Walk G u v
q : Walk G v w
⊢ Walk.map f (append p q) = append (Walk.map f p) (Walk.map f q)
Theorem: taylor_within_zero_eval
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: dsimp only [taylorWithinEval]
state_before: 𝕜 : Type ?u.139420
E : Type u_1
F : Type ?u.139426
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ taylorWithinEval f 0 s x₀ x = f x₀

tactic: dsimp only [taylorWithin]
state_before: 𝕜 : Type ?u.139420
E : Type u_1
F : Type ?u.139426
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ ↑(PolynomialModule.eval x) (taylorWithin f 0 s x₀) = f x₀

tactic: dsimp only [taylorCoeffWithin]
state_before: 𝕜 : Type ?u.139420
E : Type u_1
F : Type ?u.139426
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ ↑(PolynomialModule.eval x)
      (∑ k in Finset.range (0 + 1),
        ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
          (↑(PolynomialModule.single ℝ k) (taylorCoeffWithin f k s x₀))) =
    f x₀

tactic: simp
state_before: 𝕜 : Type ?u.139420
E : Type u_1
F : Type ?u.139426
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ ↑(PolynomialModule.eval x)
      (∑ k in Finset.range (0 + 1),
        ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
          (↑(PolynomialModule.single ℝ k) ((↑k !)⁻¹ • iteratedDerivWithin k f s x₀))) =
    f x₀
Theorem: MeasureTheory.FiniteMeasure.coeFn_smul
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: funext
state_before: Ω : Type u_2
inst✝⁵ : MeasurableSpace Ω
R : Type u_1
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
⊢ (fun s => ENNReal.toNNReal (↑↑↑(c • μ) s)) = c • fun s => ENNReal.toNNReal (↑↑↑μ s)

tactic: simp [← ENNReal.coe_eq_coe,  ENNReal.coe_smul]
state_before: case h
Ω : Type u_2
inst✝⁵ : MeasurableSpace Ω
R : Type u_1
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
x✝ : Set Ω
⊢ ENNReal.toNNReal (↑↑↑(c • μ) x✝) = (c • fun s => ENNReal.toNNReal (↑↑↑μ s)) x✝

tactic: norm_cast
state_before: case h
Ω : Type u_2
inst✝⁵ : MeasurableSpace Ω
R : Type u_1
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
x✝ : Set Ω
⊢ ↑↑↑(c • μ) x✝ = c • ↑↑↑μ x✝
Theorem: measurableSet_of_differentiableWithinAt_Ici_of_isComplete
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: simp only [differentiable_set_eq_d K hK, D]
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K}

tactic: refine MeasurableSet.iInter fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
⊢ MeasurableSet
    (⋂ (e : ℕ), ⋃ (n : ℕ), ⋂ (p : ℕ) (_ : p ≥ n) (q : ℕ) (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ e))

tactic: refine MeasurableSet.iUnion fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝ : ℕ
⊢ MeasurableSet (⋃ (n : ℕ), ⋂ (p : ℕ) (_ : p ≥ n) (q : ℕ) (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ x✝))

tactic: refine MeasurableSet.iInter fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝¹ x✝ : ℕ
⊢ MeasurableSet (⋂ (p : ℕ) (_ : p ≥ x✝) (q : ℕ) (_ : q ≥ x✝), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ x✝¹))

tactic: refine MeasurableSet.iInter fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝² x✝¹ x✝ : ℕ
⊢ MeasurableSet (⋂ (_ : x✝ ≥ x✝¹) (q : ℕ) (_ : q ≥ x✝¹), B f K ((1 / 2) ^ x✝) ((1 / 2) ^ q) ((1 / 2) ^ x✝²))

tactic: refine MeasurableSet.iInter fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝³ x✝² x✝¹ : ℕ
x✝ : x✝¹ ≥ x✝²
⊢ MeasurableSet (⋂ (q : ℕ) (_ : q ≥ x✝²), B f K ((1 / 2) ^ x✝¹) ((1 / 2) ^ q) ((1 / 2) ^ x✝³))

tactic: refine MeasurableSet.iInter fun _ => ?_
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝⁴ x✝³ x✝² : ℕ
x✝¹ : x✝² ≥ x✝³
x✝ : ℕ
⊢ MeasurableSet (⋂ (_ : x✝ ≥ x✝³), B f K ((1 / 2) ^ x✝²) ((1 / 2) ^ x✝) ((1 / 2) ^ x✝⁴))

tactic: exact measurableSet_b
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
x✝⁵ x✝⁴ x✝³ : ℕ
x✝² : x✝³ ≥ x✝⁴
x✝¹ : ℕ
x✝ : x✝¹ ≥ x✝⁴
⊢ MeasurableSet (B f K ((1 / 2) ^ x✝³) ((1 / 2) ^ x✝¹) ((1 / 2) ^ x✝⁵))
Theorem: completeSpace_iff_ultrafilter
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp [completeSpace_iff_isComplete_univ, isComplete_iff_ultrafilter]
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
⊢ CompleteSpace α ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → ∃ x, ↑l ≤ 𝓝 x
Theorem: Real.Angle.cos_sin_inj
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc
state_before: θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
⊢ ↑θ = ↑ψ

tactic: cases' sin_eq_iff_coe_eq_or_add_eq_pi.mp Hsin with hs hs
state_before: case inr
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑θ = -↑ψ
⊢ ↑θ = ↑ψ

tactic: rw [eq_neg_iff_add_eq_zero, hs] at hc
state_before: case inr.inr
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑θ = -↑ψ
hs : ↑θ + ↑ψ = ↑π
⊢ ↑θ = ↑ψ

tactic: obtain ⟨n, hn⟩ : ∃ n, n • _ = _ := QuotientAddGroup.leftRel_apply.mp (Quotient.exact' hc)
state_before: case inr.inr
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑π = 0
hs : ↑θ + ↑ψ = ↑π
⊢ ↑θ = ↑ψ

tactic: rw [← neg_one_mul, add_zero, ← sub_eq_zero, zsmul_eq_mul, ← mul_assoc, ← sub_mul, mul_eq_zero,
  eq_false (ne_of_gt pi_pos), or_false_iff, sub_neg_eq_add, ← Int.cast_zero, ← Int.cast_one,
  ← Int.int_cast_ofNat,  ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
state_before: case inr.inr.intro
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑π = 0
hs : ↑θ + ↑ψ = ↑π
n : ℤ
hn : n • (2 * π) = -π + 0
⊢ ↑θ = ↑ψ

tactic: rw [add_comm, Int.add_mul_emod_self] at this
state_before: case inr.inr.intro
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑π = 0
hs : ↑θ + ↑ψ = ↑π
n : ℤ
hn✝ : n • (2 * π) = -1 * π
hn : n * 2 + 1 = 0
this : (n * 2 + 1) % 2 = 0 % 2
⊢ ↑θ = ↑ψ

tactic: exact absurd this one_ne_zero
state_before: case inr.inr.intro
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑π = 0
hs : ↑θ + ↑ψ = ↑π
n : ℤ
hn✝ : n • (2 * π) = -1 * π
hn : n * 2 + 1 = 0
this : 1 % 2 = 0 % 2
⊢ ↑θ = ↑ψ

tactic: exact hc
state_before: case inl
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑θ = ↑ψ
⊢ ↑θ = ↑ψ

tactic: exact hs
state_before: case inr.inl
θ ψ : ℝ
Hcos : cos θ = cos ψ
Hsin : sin θ = sin ψ
hc : ↑θ = -↑ψ
hs : ↑θ = ↑ψ
⊢ ↑θ = ↑ψ
Theorem: Bornology.cobounded_eq_bot_iff
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [← isBounded_univ, isBounded_def, compl_univ, empty_mem_iff_bot]
state_before: ι : Type ?u.10138
α : Type u_1
β : Type ?u.10144
inst✝ : Bornology α
⊢ cobounded α = ⊥ ↔ BoundedSpace α
Theorem: Finset.fold_op_distrib
File: Mathlib/Data/Finset/Fold.lean

tactic: simp only [fold, fold_distrib]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.9400
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f✝ : α → β
b : β
s : Finset α
a : α
f g : α → β
b₁ b₂ : β
⊢ fold op (op b₁ b₂) (fun x => op (f x) (g x)) s = op (fold op b₁ f s) (fold op b₂ g s)
Theorem: ProjectiveSpectrum.vanishingIdeal_union
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: ext1
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ vanishingIdeal (t ∪ t') = vanishingIdeal t ⊓ vanishingIdeal t'

tactic: exact (gc_ideal 𝒜).u_inf
state_before: case h
R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ HomogeneousIdeal.toIdeal (vanishingIdeal (t ∪ t')) = HomogeneousIdeal.toIdeal (vanishingIdeal t ⊓ vanishingIdeal t')
Theorem: Finset.uIcc_subset_uIcc_union_uIcc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: push_cast
state_before: ι : Type ?u.208607
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ ↑[[a, c]] ⊆ ↑([[a, b]] ∪ [[b, c]])

tactic: exact Set.uIcc_subset_uIcc_union_uIcc
state_before: ι : Type ?u.208607
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c
Theorem: Real.logb_nonpos_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← not_lt, logb_pos_iff hb hx, not_lt]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b x ≤ 0 ↔ x ≤ 1
Theorem: MvPolynomial.eval₂Hom_zero
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: ext <;> simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p q : MvPolynomial σ R
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
⊢ eval₂Hom f 0 = RingHom.comp f constantCoeff
Theorem: PNat.dvd_iff
File: Mathlib/Data/PNat/Basic.lean

tactic: constructor <;> intro h
state_before: k m : ℕ+
⊢ k ∣ m ↔ ↑k ∣ ↑m

tactic: rcases h with ⟨_, rfl⟩
state_before: case mp
k m : ℕ+
h : k ∣ m
⊢ ↑k ∣ ↑m

tactic: apply dvd_mul_right
state_before: case mp.intro
k w✝ : ℕ+
⊢ ↑k ∣ ↑(k * w✝)

tactic: rcases h with ⟨a, h⟩
state_before: case mpr
k m : ℕ+
h : ↑k ∣ ↑m
⊢ k ∣ m

tactic: cases a with
| zero =>
  contrapose h
  apply ne_zero
| succ n =>
  use ⟨n.succ, n.succ_pos⟩
  rw [← coe_inj, h, mul_coe, mk_coe]
state_before: case mpr.intro
k m : ℕ+
a : ℕ
h : ↑m = ↑k * a
⊢ k ∣ m

tactic: contrapose h
state_before: case mpr.intro.zero
k m : ℕ+
h : ↑m = ↑k * zero
⊢ k ∣ m

tactic: apply ne_zero
state_before: case mpr.intro.zero
k m : ℕ+
h : ¬k ∣ m
⊢ ¬↑m = ↑k * zero

tactic: use ⟨n.succ, n.succ_pos⟩
state_before: case mpr.intro.succ
k m : ℕ+
n : ℕ
h : ↑m = ↑k * succ n
⊢ k ∣ m

tactic: rw [← coe_inj, h, mul_coe, mk_coe]
state_before: case mpr.intro.succ
k m : ℕ+
n : ℕ
h : ↑m = ↑k * succ n
⊢ m = k * { val := succ n, property := (_ : 0 < succ n) }
Theorem: Multiset.aemeasurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.aemeasurable_prod' hs
state_before: M : Type u_1
ι : Type ?u.4511300
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
s : Multiset (α → M)
hs : ∀ (f : α → M), f ∈ s → AEMeasurable f
⊢ AEMeasurable fun x => prod (map (fun f => f x) s)
Theorem: Filter.lift'_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [inf_principal, comp, hg]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.43806
ι : Sort u_3
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
s t : Set α
⊢ (𝓟 ∘ g) (s ∩ t) = (𝓟 ∘ g) s ⊓ (𝓟 ∘ g) t

tactic: rw [Function.comp_apply, hg', principal_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.43806
ι : Sort u_3
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
⊢ (𝓟 ∘ g) univ = ⊤
Theorem: Ordinal.principal_mul_iff_mul_left_eq
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' ⟨fun h a ha₀ hao => _, fun h a b hao hbo => _⟩
state_before: o : Ordinal
⊢ Principal (fun x x_1 => x * x_1) o ↔ ∀ (a : Ordinal), 0 < a → a < o → a * o = o

tactic: cases' le_or_gt o 2 with ho ho
state_before: case refine'_1
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
⊢ a * o = o

tactic: convert one_mul o
state_before: case refine'_1.inl
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ a * o = o

tactic: apply le_antisymm
state_before: case h.e'_2.h.e'_5
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ a = 1

tactic: have : a < succ 1 := hao.trans_le (by simpa using ho)
state_before: case h.e'_2.h.e'_5.a
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ a ≤ 1

tactic: rwa [lt_succ_iff] at this
state_before: case h.e'_2.h.e'_5.a
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
this : a < succ 1
⊢ a ≤ 1

tactic: simpa using ho
state_before: o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ o ≤ succ 1

tactic: rwa [← succ_le_iff, succ_zero] at ha₀
state_before: case h.e'_2.h.e'_5.a
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ 1 ≤ a

tactic: exact op_eq_self_of_principal hao (mul_isNormal ha₀) h (principal_mul_isLimit ho h)
state_before: case refine'_1.inr
o : Ordinal
h : Principal (fun x x_1 => x * x_1) o
a : Ordinal
ha₀ : 0 < a
hao : a < o
ho : o > 2
⊢ a * o = o

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case refine'_2
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
a b : Ordinal
hao : a < o
hbo : b < o
⊢ (fun x x_1 => x * x_1) a b < o

tactic: rw [← Ordinal.pos_iff_ne_zero] at ha
state_before: case refine'_2.inr
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
a b : Ordinal
hao : a < o
hbo : b < o
ha : a ≠ 0
⊢ (fun x x_1 => x * x_1) a b < o

tactic: rw [← h a ha hao]
state_before: case refine'_2.inr
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
a b : Ordinal
hao : a < o
hbo : b < o
ha : 0 < a
⊢ (fun x x_1 => x * x_1) a b < o

tactic: exact (mul_isNormal ha).strictMono hbo
state_before: case refine'_2.inr
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
a b : Ordinal
hao : a < o
hbo : b < o
ha : 0 < a
⊢ (fun x x_1 => x * x_1) a b < a * o

tactic: dsimp only
state_before: case refine'_2.inl
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
b : Ordinal
hbo : b < o
hao : 0 < o
⊢ (fun x x_1 => x * x_1) 0 b < o

tactic: rwa [zero_mul]
state_before: case refine'_2.inl
o : Ordinal
h : ∀ (a : Ordinal), 0 < a → a < o → a * o = o
b : Ordinal
hbo : b < o
hao : 0 < o
⊢ 0 * b < o
Theorem: TopologicalSpace.Opens.not_nonempty_iff_eq_bot
File: Mathlib/Topology/Sets/Opens.lean

tactic: rw [← coe_inj, coe_bot, ← Set.not_nonempty_iff_eq_empty]
state_before: ι : Type ?u.28024
α : Type u_1
β : Type ?u.28030
γ : Type ?u.28033
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U : Opens α
⊢ ¬Set.Nonempty ↑U ↔ U = ⊥
Theorem: le_iff_compact_le_imp
File: Mathlib/Order/CompactlyGenerated.lean

tactic: rw [← sSup_compact_le_eq a, ← sSup_compact_le_eq b]
state_before: ι : Sort ?u.88112
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a✝ b✝ : α
s : Set α
a b : α
h : ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
⊢ a ≤ b

tactic: exact sSup_le_sSup fun c hc => ⟨hc.1, h c hc.1 hc.2⟩
state_before: ι : Sort ?u.88112
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a✝ b✝ : α
s : Set α
a b : α
h : ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ a} ≤ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b}
Theorem: Nat.add_left_comm
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [← Nat.add_assoc, Nat.add_comm n m, Nat.add_assoc]
state_before: n m k : Nat
⊢ n + (m + k) = m + (n + k)
Theorem: PiNat.update_mem_cylinder
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [hi.ne]
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : E n
i : ℕ
hi : i < n
⊢ update x n y i = x i