1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: TopCat.Presheaf.app_injective_of_stalkFunctor_map_injective
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: erw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply, hst]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : (forget C).ReflectsIsomorphisms
F : Sheaf C X
G : Presheaf C X
f : F.val ⟶ G
U : Opens ↑X
h : ∀ (x : ↥U), Function.Injective ⇑((stalkFunctor C ↑x).map f)
s t : (forget C).obj (F.val.obj { unop := U })
hst : (f.app { unop := U }) s = (f.app { unop := U }) t
x : ↥U
⊢ ((stalkFunctor C ↑x).map f) ((F.presheaf.germ x) s) = ((stalkFunctor C ↑x).map f) ((F.presheaf.germ x) t)
state_after: no goals
Theorem: MvPolynomial.mem_degrees
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: classical
simp only [degrees_def, Multiset.mem_sup, ← mem_support_iff, Finsupp.mem_toMultiset, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
⊢ i ∈ p.degrees ↔ ∃ d, coeff d p ≠ 0 ∧ i ∈ d.support
state_after: no goals

tactic: simp only [degrees_def, Multiset.mem_sup, ← mem_support_iff, Finsupp.mem_toMultiset, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
⊢ i ∈ p.degrees ↔ ∃ d, coeff d p ≠ 0 ∧ i ∈ d.support
state_after: no goals
Theorem: Real.Gamma_nonneg_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: obtain rfl | h := eq_or_lt_of_le hs
state_before: s : ℝ
hs : 0 ≤ s
⊢ 0 ≤ Gamma s
state_after: case inl
hs : 0 ≤ 0
⊢ 0 ≤ Gamma 0

case inr
s : ℝ
hs : 0 ≤ s
h : 0 < s
⊢ 0 ≤ Gamma s

tactic: rw [Gamma_zero]
state_before: case inl
hs : 0 ≤ 0
⊢ 0 ≤ Gamma 0
state_after: no goals

tactic: exact (Gamma_pos_of_pos h).le
state_before: case inr
s : ℝ
hs : 0 ≤ s
h : 0 < s
⊢ 0 ≤ Gamma s
state_after: no goals
Theorem: PiNat.shortestPrefixDiff_pos
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rcases hne with ⟨y, hy⟩
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
hne : s.Nonempty
x : (n : ℕ) → E n
hx : x ∉ s
⊢ 0 < shortestPrefixDiff x s
state_after: case intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x : (n : ℕ) → E n
hx : x ∉ s
y : (n : ℕ) → E n
hy : y ∈ s
⊢ 0 < shortestPrefixDiff x s

tactic: exact (zero_le _).trans_lt (firstDiff_lt_shortestPrefixDiff hs hx hy)
state_before: case intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x : (n : ℕ) → E n
hx : x ∉ s
y : (n : ℕ) → E n
hy : y ∈ s
⊢ 0 < shortestPrefixDiff x s
state_after: no goals
Theorem: Complex.HadamardThreeLines.norm_le_sSupNormIm
File: Mathlib/Analysis/Complex/Hadamard.lean

tactic: refine le_csSup ?_ ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ ‖f z‖ ≤ sSupNormIm f z.re
state_after: case refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ BddAbove (norm ∘ f '' (re ⁻¹' {z.re}))

case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ ‖f z‖ ∈ norm ∘ f '' (re ⁻¹' {z.re})

tactic: apply BddAbove.mono (image_subset (norm ∘ f) _) hB
state_before: case refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ BddAbove (norm ∘ f '' (re ⁻¹' {z.re}))
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ re ⁻¹' {z.re} ⊆ verticalClosedStrip 0 1

tactic: exact preimage_mono (singleton_subset_iff.mpr hD)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ re ⁻¹' {z.re} ⊆ verticalClosedStrip 0 1
state_after: no goals

tactic: apply mem_image_of_mem (norm ∘ f)
state_before: case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ ‖f z‖ ∈ norm ∘ f '' (re ⁻¹' {z.re})
state_after: case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ z ∈ re ⁻¹' {z.re}

tactic: simp only [mem_preimage, mem_singleton]
state_before: case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ z ∈ re ⁻¹' {z.re}
state_after: no goals
Theorem: homology'.π'_desc'
File: Mathlib/CategoryTheory/Abelian/Homology.lean

tactic: dsimp [π', desc']
state_before: A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : kernel g ⟶ W
he : kernel.lift g f w ≫ e = 0
⊢ π' f g w ≫ desc' f g w e he = e
state_after: A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : kernel g ⟶ W
he : kernel.lift g f w ≫ e = 0
⊢ (cokernel.π (kernel.lift g f w) ≫ (homology'IsoCokernelLift f g w).inv) ≫
      (homology'IsoCokernelLift f g w).hom ≫ cokernel.desc (kernel.lift g f w) e he =
    e

tactic: simp
state_before: A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : kernel g ⟶ W
he : kernel.lift g f w ≫ e = 0
⊢ (cokernel.π (kernel.lift g f w) ≫ (homology'IsoCokernelLift f g w).inv) ≫
      (homology'IsoCokernelLift f g w).hom ≫ cokernel.desc (kernel.lift g f w) e he =
    e
state_after: no goals
Theorem: Complex.cos_eq_neg_one_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← neg_eq_iff_eq_neg, ← cos_sub_pi, cos_eq_one_iff]
state_before: x : ℂ
⊢ cos x = -1 ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x
state_after: x : ℂ
⊢ (∃ k, ↑k * (2 * ↑π) = x - ↑π) ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x

tactic: simp only [eq_sub_iff_add_eq']
state_before: x : ℂ
⊢ (∃ k, ↑k * (2 * ↑π) = x - ↑π) ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x
state_after: no goals
Theorem: hammingDist_eq_hammingNorm
File: Mathlib/InformationTheory/Hamming.lean

tactic: simp_rw [hammingNorm, hammingDist, Pi.sub_apply, sub_ne_zero]
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝³ : Fintype ι
inst✝² : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝¹ : (i : ι) → DecidableEq (γ i)
inst✝ : (i : ι) → AddGroup (β i)
x y : (i : ι) → β i
⊢ hammingDist x y = hammingNorm (x - y)
state_after: no goals
Theorem: TensorAlgebra.toDirectSum_comp_ofDirectSum
File: Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ toDirectSum.comp ofDirectSum = AlgHom.id R (⨁ (n : ℕ), ⨂[R]^n M)
state_after: case h.H.H
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
i✝ : ℕ
x✝ : Fin i✝ → M
⊢ (((toDirectSum.comp ofDirectSum).toLinearMap ∘ₗ DirectSum.lof R ℕ (fun i => ⨂[R]^i M) i✝).compMultilinearMap
        (PiTensorProduct.tprod R))
      x✝ =
    (((AlgHom.id R (⨁ (n : ℕ), ⨂[R]^n M)).toLinearMap ∘ₗ DirectSum.lof R ℕ (fun i => ⨂[R]^i M) i✝).compMultilinearMap
        (PiTensorProduct.tprod R))
      x✝

tactic: simp [DirectSum.lof_eq_of, -tprod_apply, toDirectSum_tensorPower_tprod]
state_before: case h.H.H
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
i✝ : ℕ
x✝ : Fin i✝ → M
⊢ (((toDirectSum.comp ofDirectSum).toLinearMap ∘ₗ DirectSum.lof R ℕ (fun i => ⨂[R]^i M) i✝).compMultilinearMap
        (PiTensorProduct.tprod R))
      x✝ =
    (((AlgHom.id R (⨁ (n : ℕ), ⨂[R]^n M)).toLinearMap ∘ₗ DirectSum.lof R ℕ (fun i => ⨂[R]^i M) i✝).compMultilinearMap
        (PiTensorProduct.tprod R))
      x✝
state_after: no goals
Theorem: cauchy_iff_le
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp only [Cauchy, hl, true_and]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
l : Filter α
hl : l.NeBot
⊢ Cauchy l ↔ l ×ˢ l ≤ 𝓤 α
state_after: no goals
Theorem: IsLindelof.induction_on
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: let f : Filter X := ofCountableUnion p hcountable_union (fun t ht _ hsub ↦ hmono hsub ht)
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
⊢ p s
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
f : Filter X := ofCountableUnion p hcountable_union ⋯
⊢ p s

tactic: have : sᶜ ∈ f := hs.compl_mem_sets_of_nhdsWithin (by simpa [f] using hnhds)
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
f : Filter X := ofCountableUnion p hcountable_union ⋯
⊢ p s
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
f : Filter X := ofCountableUnion p hcountable_union ⋯
this : sᶜ ∈ f
⊢ p s

tactic: rwa [← compl_compl s]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
f : Filter X := ofCountableUnion p hcountable_union ⋯
this : sᶜ ∈ f
⊢ p s
state_after: no goals

tactic: simpa [f] using hnhds
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
p : Set X → Prop
hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → p t → p s
hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S)
hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t
f : Filter X := ofCountableUnion p hcountable_union ⋯
⊢ ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
state_after: no goals
Theorem: DFinsupp.single_eq_zero
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [← single_zero i, single_eq_single_iff]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ single i xi = 0 ↔ xi = 0
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ i = i ∧ HEq xi 0 ∨ xi = 0 ∧ 0 = 0 ↔ xi = 0

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ i = i ∧ HEq xi 0 ∨ xi = 0 ∧ 0 = 0 ↔ xi = 0
state_after: no goals
Theorem: threeGPFree_image
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: rw [ThreeGPFree, ThreeGPFree]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a : α
hf : IsMulFreimanIso 2 s t f
hAs : A ⊆ s
⊢ ThreeGPFree (f '' A) ↔ ThreeGPFree A
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a : α
hf : IsMulFreimanIso 2 s t f
hAs : A ⊆ s
⊢ (∀ ⦃a : β⦄, a ∈ f '' A → ∀ ⦃b : β⦄, b ∈ f '' A → ∀ ⦃c : β⦄, c ∈ f '' A → a * c = b * b → a = b) ↔
    ∀ ⦃a : α⦄, a ∈ A → ∀ ⦃b : α⦄, b ∈ A → ∀ ⦃c : α⦄, c ∈ A → a * c = b * b → a = b

tactic: have := (hf.bijOn.injOn.mono hAs).bijOn_image (f := f)
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a : α
hf : IsMulFreimanIso 2 s t f
hAs : A ⊆ s
⊢ (∀ ⦃a : β⦄, a ∈ f '' A → ∀ ⦃b : β⦄, b ∈ f '' A → ∀ ⦃c : β⦄, c ∈ f '' A → a * c = b * b → a = b) ↔
    ∀ ⦃a : α⦄, a ∈ A → ∀ ⦃b : α⦄, b ∈ A → ∀ ⦃c : α⦄, c ∈ A → a * c = b * b → a = b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a : α
hf : IsMulFreimanIso 2 s t f
hAs : A ⊆ s
this : BijOn f A (f '' A)
⊢ (∀ ⦃a : β⦄, a ∈ f '' A → ∀ ⦃b : β⦄, b ∈ f '' A → ∀ ⦃c : β⦄, c ∈ f '' A → a * c = b * b → a = b) ↔
    ∀ ⦃a : α⦄, a ∈ A → ∀ ⦃b : α⦄, b ∈ A → ∀ ⦃c : α⦄, c ∈ A → a * c = b * b → a = b

tactic: simp (config := { contextual := true }) only
  [((hf.bijOn.injOn.mono hAs).bijOn_image (f := f)).forall,
  hf.mul_eq_mul (hAs _) (hAs _) (hAs _) (hAs _), this.injOn.eq_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a : α
hf : IsMulFreimanIso 2 s t f
hAs : A ⊆ s
this : BijOn f A (f '' A)
⊢ (∀ ⦃a : β⦄, a ∈ f '' A → ∀ ⦃b : β⦄, b ∈ f '' A → ∀ ⦃c : β⦄, c ∈ f '' A → a * c = b * b → a = b) ↔
    ∀ ⦃a : α⦄, a ∈ A → ∀ ⦃b : α⦄, b ∈ A → ∀ ⦃c : α⦄, c ∈ A → a * c = b * b → a = b
state_after: no goals
Theorem: Real.Angle.sin_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_or, ← sin_eq_zero_iff]
state_before: θ : Angle
⊢ θ.sin ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π
state_after: no goals
Theorem: Matrix.one_eq_pi_single
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [one_apply, Pi.single_apply, eq_comm]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
i j : n
⊢ 1 i j = Pi.single i 1 j
state_after: no goals
Theorem: Polynomial.funext
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [← sub_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ p = q
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ p - q = 0

tactic: apply zero_of_eval_zero
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ p - q = 0
state_after: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ ∀ (x : R), eval x (p - q) = 0

tactic: intro x
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ ∀ (x : R), eval x (p - q) = 0
state_after: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
x : R
⊢ eval x (p - q) = 0

tactic: rw [eval_sub, sub_eq_zero, ext]
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
x : R
⊢ eval x (p - q) = 0
state_after: no goals
Theorem: Polynomial.degree_quadratic_lt_degree_C_mul_X_cb
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simpa only [degree_C_mul_X_pow 3 ha] using degree_quadratic_lt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C b * X ^ 2 + C c * X + C d).degree < (C a * X ^ 3).degree
state_after: no goals
Theorem: MeasureTheory.lintegral_biUnion₀
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: haveI := ht.toEncodable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
t : Set β
s : β → Set α
ht : t.Countable
hm : ∀ i ∈ t, NullMeasurableSet (s i) μ
hd : t.Pairwise (AEDisjoint μ on s)
f : α → ℝ≥0∞
⊢ ∫⁻ (a : α) in ⋃ i ∈ t, s i, f a ∂μ = ∑' (i : ↑t), ∫⁻ (a : α) in s ↑i, f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
t : Set β
s : β → Set α
ht : t.Countable
hm : ∀ i ∈ t, NullMeasurableSet (s i) μ
hd : t.Pairwise (AEDisjoint μ on s)
f : α → ℝ≥0∞
this : Encodable ↑t
⊢ ∫⁻ (a : α) in ⋃ i ∈ t, s i, f a ∂μ = ∑' (i : ↑t), ∫⁻ (a : α) in s ↑i, f a ∂μ

tactic: rw [biUnion_eq_iUnion, lintegral_iUnion₀ (SetCoe.forall'.1 hm) (hd.subtype _ _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
t : Set β
s : β → Set α
ht : t.Countable
hm : ∀ i ∈ t, NullMeasurableSet (s i) μ
hd : t.Pairwise (AEDisjoint μ on s)
f : α → ℝ≥0∞
this : Encodable ↑t
⊢ ∫⁻ (a : α) in ⋃ i ∈ t, s i, f a ∂μ = ∑' (i : ↑t), ∫⁻ (a : α) in s ↑i, f a ∂μ
state_after: no goals
Theorem: WittVector.frobeniusPolyAux_eq
File: Mathlib/RingTheory/WittVector/Frobenius.lean

tactic: rw [frobeniusPolyAux, ← Fin.sum_univ_eq_sum_range]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ frobeniusPolyAux p n =
    X (n + 1) -
      ∑ i ∈ range n,
        ∑ j ∈ range (p ^ (n - i)),
          (X i ^ p) ^ (p ^ (n - i) - (j + 1)) * frobeniusPolyAux p i ^ (j + 1) *
            C ↑((p ^ (n - i)).choose (j + 1) / p ^ (n - i - v p ⟨j + 1, ⋯⟩) * p ^ (j - v p ⟨j + 1, ⋯⟩))
state_after: no goals
Theorem: Set.isAtom_iff
File: Mathlib/Order/Atoms.lean

tactic: refine
  ⟨?_, by
    rintro ⟨x, rfl⟩
    exact isAtom_singleton x⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s ↔ ∃ x, s = {x}
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s → ∃ x, s = {x}

tactic: rw [isAtom_iff_le_of_ge, bot_eq_empty, ← nonempty_iff_ne_empty]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s → ∃ x, s = {x}
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (s.Nonempty ∧ ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b) → ∃ x, s = {x}

tactic: rintro ⟨⟨x, hx⟩, hs⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (s.Nonempty ∧ ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b) → ∃ x, s = {x}
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
hs : ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b
x : α
hx : x ∈ s
⊢ ∃ x, s = {x}

tactic: exact
  ⟨x, eq_singleton_iff_unique_mem.2
      ⟨hx, fun y hy => (hs {y} (singleton_ne_empty _) (singleton_subset_iff.2 hy) hx).symm⟩⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
hs : ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b
x : α
hx : x ∈ s
⊢ ∃ x, s = {x}
state_after: no goals

tactic: rintro ⟨x, rfl⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (∃ x, s = {x}) → IsAtom s
state_after: case intro
ι : Sort u_1
α : Type u_2
β : Type u_3
x : α
⊢ IsAtom {x}

tactic: exact isAtom_singleton x
state_before: case intro
ι : Sort u_1
α : Type u_2
β : Type u_3
x : α
⊢ IsAtom {x}
state_after: no goals
Theorem: NNReal.one_lt_coe
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [← coe_lt_coe, coe_one]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ 1 < ↑r ↔ 1 < r
state_after: no goals
Theorem: Vector.tendsto_insertNth
File: Mathlib/Topology/List.lean

tactic: rw [insertNth, tendsto_subtype_rng]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : l.length = n
⊢ Tendsto (fun p => insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 ⟨l, hl⟩) (𝓝 (insertNth a i ⟨l, hl⟩))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : l.length = n
⊢ Tendsto (fun x => ↑(insertNth x.1 i x.2)) (𝓝 a ×ˢ 𝓝 ⟨l, hl⟩) (𝓝 ↑⟨List.insertNth (↑i) a ↑⟨l, hl⟩, ⋯⟩)

tactic: simp only [insertNth_val]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : l.length = n
⊢ Tendsto (fun x => ↑(insertNth x.1 i x.2)) (𝓝 a ×ˢ 𝓝 ⟨l, hl⟩) (𝓝 ↑⟨List.insertNth (↑i) a ↑⟨l, hl⟩, ⋯⟩)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : l.length = n
⊢ Tendsto (fun x => List.insertNth (↑i) x.1 ↑x.2) (𝓝 a ×ˢ 𝓝 ⟨l, hl⟩) (𝓝 (List.insertNth (↑i) a l))

tactic: exact List.tendsto_insertNth tendsto_fst (Tendsto.comp continuousAt_subtype_val tendsto_snd : _)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : l.length = n
⊢ Tendsto (fun x => List.insertNth (↑i) x.1 ↑x.2) (𝓝 a ×ˢ 𝓝 ⟨l, hl⟩) (𝓝 (List.insertNth (↑i) a l))
state_after: no goals
Theorem: LinearMap.BilinForm.nondegenerate_toBilin'_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [Matrix.nondegenerate_toBilin'_iff, Matrix.nondegenerate_iff_det_ne_zero]
state_before: R : Type u_1
M✝ : Type u_2
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : AddCommMonoid M✝
inst✝¹⁷ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁶ : CommRing R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_11
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_12
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
M : Matrix ι ι A
⊢ (toBilin' M).Nondegenerate ↔ M.det ≠ 0
state_after: no goals