1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Subspace.comap_dualAnnihilator_dualAnnihilator
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
⊢ comap (Module.Dual.eval K V) (dualAnnihilator W).dualAnnihilator = W
state_after: case h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
x✝ : V
⊢ x✝ ∈ comap (Module.Dual.eval K V) (dualAnnihilator W).dualAnnihilator ↔ x✝ ∈ W

tactic: rw [Iff.comm, ← forall_mem_dualAnnihilator_apply_eq_zero_iff]
state_before: case h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
x✝ : V
⊢ x✝ ∈ comap (Module.Dual.eval K V) (dualAnnihilator W).dualAnnihilator ↔ x✝ ∈ W
state_after: case h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
x✝ : V
⊢ (∀ φ ∈ dualAnnihilator W, φ x✝ = 0) ↔ x✝ ∈ comap (Module.Dual.eval K V) (dualAnnihilator W).dualAnnihilator

tactic: simp
state_before: case h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
x✝ : V
⊢ (∀ φ ∈ dualAnnihilator W, φ x✝ = 0) ↔ x✝ ∈ comap (Module.Dual.eval K V) (dualAnnihilator W).dualAnnihilator
state_after: no goals
Theorem: FirstOrder.Language.Substructure.subset_closure_withConstants
File: Mathlib/ModelTheory/Substructures.lean

tactic: intro a ha
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
⊢ A ⊆ ↑((closure (L[[↑A]])).toFun s)
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
⊢ a ∈ ↑((closure (L[[↑A]])).toFun s)

tactic: simp only [SetLike.mem_coe]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
⊢ a ∈ ↑((closure (L[[↑A]])).toFun s)
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
⊢ a ∈ (closure (L[[↑A]])).toFun s

tactic: let a' : L[[A]].Constants := Sum.inr ⟨a, ha⟩
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
⊢ a ∈ (closure (L[[↑A]])).toFun s
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
a' : L[[↑A]].Constants := Sum.inr ⟨a, ha⟩
⊢ a ∈ (closure (L[[↑A]])).toFun s

tactic: exact constants_mem a'
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
A s : Set M
h : A ⊆ ↑S
a : M
ha : a ∈ A
a' : L[[↑A]].Constants := Sum.inr ⟨a, ha⟩
⊢ a ∈ (closure (L[[↑A]])).toFun s
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.integral_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [MeasureTheory.integral_eq f hfi, ← L1.SimpleFunc.toLp_one_eq_toL1,
  L1.SimpleFunc.integral_L1_eq_integral, L1.SimpleFunc.integral_eq_integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = ∫ (x : α), ↑f x ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = integral μ (Lp.simpleFunc.toSimpleFunc (Lp.simpleFunc.toLp f ⋯))

tactic: exact SimpleFunc.integral_congr hfi (Lp.simpleFunc.toSimpleFunc_toLp _ _).symm
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = integral μ (Lp.simpleFunc.toSimpleFunc (Lp.simpleFunc.toLp f ⋯))
state_after: no goals
Theorem: Polynomial.cyclotomic.roots_eq_primitiveRoots_val
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean

tactic: rw [← cyclotomic.roots_to_finset_eq_primitiveRoots]
state_before: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
⊢ (cyclotomic n R).roots = (primitiveRoots n R).val
state_after: no goals
Theorem: compl_symmDiff_compl
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [compl_sdiff_compl, sdiff_eq, symmDiff_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ bᶜ \ aᶜ ⊔ aᶜ \ bᶜ = a ∆ b
state_after: no goals
Theorem: WithZeroTopology.tendsto_of_ne_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_of_ne_zero h, tendsto_pure]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ✝ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
γ : Γ₀
h : γ ≠ 0
⊢ Tendsto f l (𝓝 γ) ↔ ∀ᶠ (x : α) in l, f x = γ
state_after: no goals
Theorem: toDual_compares_toDual
File: Mathlib/Order/Compare.lean

tactic: cases o
state_before: α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
o : Ordering
⊢ o.Compares (toDual a) (toDual b) ↔ o.Compares b a
state_after: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ lt.Compares (toDual a) (toDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ eq.Compares (toDual a) (toDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ gt.Compares (toDual a) (toDual b) ↔ gt.Compares b a

tactic: exacts [Iff.rfl, eq_comm, Iff.rfl]
state_before: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ lt.Compares (toDual a) (toDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ eq.Compares (toDual a) (toDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ gt.Compares (toDual a) (toDual b) ↔ gt.Compares b a
state_after: no goals
Theorem: CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
r s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (P.lift r ≫ (P.conePointsIsoOfNatIso Q w).hom) ≫ t.π.app j = map r Q w.hom ≫ t.π.app j
state_after: no goals
Theorem: ZMod.smul_mem
File: Mathlib/Data/ZMod/Module.lean

tactic: rw [← ZMod.intCast_zmod_cast c, ← zsmul_eq_smul_cast]
state_before: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c • x ∈ K
state_after: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c.cast • x ∈ K

tactic: exact zsmul_mem hx (cast c)
state_before: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c.cast • x ∈ K
state_after: no goals
Theorem: Equiv.Perm.coe_subsingleton
File: Mathlib/Logic/Equiv/Defs.lean

tactic: rw [Perm.subsingleton_eq_refl e, coe_refl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : Subsingleton α
e : Perm α
⊢ ⇑e = id
state_after: no goals
Theorem: tendsto_ceil_atBot
File: Mathlib/Topology/Algebra/Order/Floor.lean

tactic: rw [ceil_intCast]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
b : ℤ
⊢ ⌈↑(b - 1)⌉ ≤ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
b : ℤ
⊢ b - 1 ≤ b

tactic: exact (sub_one_lt _).le
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
b : ℤ
⊢ b - 1 ≤ b
state_after: no goals
Theorem: covBy_iff_coatom_Iic
File: Mathlib/Order/Atoms.lean

tactic: simp
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b : α
h : a ≤ b
⊢ a ⋖ b ↔ IsCoatom ⟨a, h⟩
state_after: no goals
Theorem: Polynomial.eq_one_of_roots_le
File: Mathlib/Topology/Algebra/Polynomial.lean

tactic: contrapose! hB
state_before: α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
hB : B < 0
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
⊢ p.natDegree = 0
state_after: α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : p.natDegree ≠ 0
⊢ 0 ≤ B

tactic: rw [← h1.natDegree_map f, natDegree_eq_card_roots' h2] at hB
state_before: α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : p.natDegree ≠ 0
⊢ 0 ≤ B
state_after: α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : card (map f p).roots ≠ 0
⊢ 0 ≤ B

tactic: obtain ⟨z, hz⟩ := card_pos_iff_exists_mem.mp (zero_lt_iff.mpr hB)
state_before: α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : card (map f p).roots ≠ 0
⊢ 0 ≤ B
state_after: case intro
α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : card (map f p).roots ≠ 0
z : K
hz : z ∈ (map f p).roots
⊢ 0 ≤ B

tactic: exact le_trans (norm_nonneg _) (h3 z hz)
state_before: case intro
α : Type u_1
R : Type u_2
inst✝³ : NormedRing R
inst✝² : IsAbsoluteValue norm
F : Type u_3
K : Type u_4
inst✝¹ : CommRing F
inst✝ : NormedField K
p : F[X]
f : F →+* K
B : ℝ
h1 : p.Monic
h2 : Splits f p
h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B
hB : card (map f p).roots ≠ 0
z : K
hz : z ∈ (map f p).roots
⊢ 0 ≤ B
state_after: no goals
Theorem: MeasureTheory.Measure.bind_zero_left
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: simp [bind]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
⊢ bind 0 f = 0
state_after: no goals
Theorem: LieModuleHom.mk_coe
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
h : ∀ {x : L} {m : M}, (↑f).toFun ⁅x, m⁆ = ⁅x, (↑f).toFun m⁆
⊢ { toLinearMap := ↑f, map_lie' := h } = f
state_after: no goals
Theorem: CategoryTheory.Mat.id_apply_self
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

tactic: simp [id_apply]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type u
inst✝ : Semiring R
M : Mat R
i : ↑M
⊢ 𝟙 M i i = 1
state_after: no goals
Theorem: LaurentPolynomial.degree_C_mul_T
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: rw [degree]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n).degree = ↑n
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n).support.max = ↑n

tactic: have : Finsupp.support (C a * T n) = {n} := by
  refine support_eq_singleton.mpr ?_
  rw [← single_eq_C_mul_T]
  simp only [single_eq_same, a0, Ne, not_false_iff, eq_self_iff_true, and_self_iff]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n).support.max = ↑n
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (C a * T n).support = {n}
⊢ (C a * T n).support.max = ↑n

tactic: rw [this]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (C a * T n).support = {n}
⊢ (C a * T n).support.max = ↑n
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (C a * T n).support = {n}
⊢ {n}.max = ↑n

tactic: exact Finset.max_singleton
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (C a * T n).support = {n}
⊢ {n}.max = ↑n
state_after: no goals

tactic: refine support_eq_singleton.mpr ?_
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n).support = {n}
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n) n ≠ 0 ∧ C a * T n = Finsupp.single n ((C a * T n) n)

tactic: rw [← single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (C a * T n) n ≠ 0 ∧ C a * T n = Finsupp.single n ((C a * T n) n)
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (Finsupp.single n a) n ≠ 0 ∧ Finsupp.single n a = Finsupp.single n ((Finsupp.single n a) n)

tactic: simp only [single_eq_same, a0, Ne, not_false_iff, eq_self_iff_true, and_self_iff]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (Finsupp.single n a) n ≠ 0 ∧ Finsupp.single n a = Finsupp.single n ((Finsupp.single n a) n)
state_after: no goals
Theorem: Polynomial.coeff_update_ne
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [p.coeff_update_apply, if_neg h]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
i : ℕ
h : i ≠ n
⊢ (p.update n a).coeff i = p.coeff i
state_after: no goals
Theorem: eq_of_slope_eq_zero
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

tactic: rw [← sub_smul_slope_vadd f a b, h, smul_zero, zero_vadd]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
h : slope f a b = 0
⊢ f a = f b
state_after: no goals
Theorem: Set.unbounded_le_inter_not_le
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Unbounded (fun x x_1 => x ≤ x_1) (s ∩ {b | ¬b ≤ a}) ↔ Unbounded (fun x x_1 => x ≤ x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | ¬b ≤ a}) ↔ Bounded (fun x x_1 => x ≤ x_1) s

tactic: exact bounded_le_inter_not_le a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | ¬b ≤ a}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
state_after: no goals
Theorem: Batteries.AssocList.toList_replace
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [replace]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
b : β
l : AssocList α β
⊢ (replace a b l).toList = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) l.toList
state_after: case cons
α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
b : β
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ : (replace a b tail✝).toList = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) tail✝.toList
⊢ (match key✝ == a with
      | true => cons a b tail✝
      | false => cons key✝ value✝ (replace a b tail✝)).toList =
    match bif key✝ == a then some (a, b) else none with
    | none => (key✝, value✝) :: List.replaceF (fun x => bif x.fst == a then some (a, b) else none) tail✝.toList
    | some a => a :: tail✝.toList

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
b : β
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ : (replace a b tail✝).toList = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) tail✝.toList
⊢ (match key✝ == a with
      | true => cons a b tail✝
      | false => cons key✝ value✝ (replace a b tail✝)).toList =
    match bif key✝ == a then some (a, b) else none with
    | none => (key✝, value✝) :: List.replaceF (fun x => bif x.fst == a then some (a, b) else none) tail✝.toList
    | some a => a :: tail✝.toList
state_after: no goals
Theorem: simply_connected_iff_paths_homotopic'
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/SimplyConnected.lean

tactic: convert simply_connected_iff_paths_homotopic (Y := Y)
state_before: Y : Type u_1
inst✝ : TopologicalSpace Y
⊢ SimplyConnectedSpace Y ↔ PathConnectedSpace Y ∧ ∀ {x y : Y} (p₁ p₂ : Path x y), p₁.Homotopic p₂
state_after: case h.e'_2.h.e'_2.h.h.a
Y : Type u_1
inst✝ : TopologicalSpace Y
a✝¹ a✝ : Y
⊢ (∀ (p₁ p₂ : Path a✝¹ a✝), p₁.Homotopic p₂) ↔ Subsingleton (Path.Homotopic.Quotient a✝¹ a✝)

tactic: simp [Path.Homotopic.Quotient, Setoid.eq_top_iff]
state_before: case h.e'_2.h.e'_2.h.h.a
Y : Type u_1
inst✝ : TopologicalSpace Y
a✝¹ a✝ : Y
⊢ (∀ (p₁ p₂ : Path a✝¹ a✝), p₁.Homotopic p₂) ↔ Subsingleton (Path.Homotopic.Quotient a✝¹ a✝)
state_after: case h.e'_2.h.e'_2.h.h.a
Y : Type u_1
inst✝ : TopologicalSpace Y
a✝¹ a✝ : Y
⊢ (∀ (p₁ p₂ : Path a✝¹ a✝), p₁.Homotopic p₂) ↔ ∀ (x y : Path a✝¹ a✝), (Path.Homotopic.setoid a✝¹ a✝).Rel x y

tactic: rfl
state_before: case h.e'_2.h.e'_2.h.h.a
Y : Type u_1
inst✝ : TopologicalSpace Y
a✝¹ a✝ : Y
⊢ (∀ (p₁ p₂ : Path a✝¹ a✝), p₁.Homotopic p₂) ↔ ∀ (x y : Path a✝¹ a✝), (Path.Homotopic.setoid a✝¹ a✝).Rel x y
state_after: no goals
Theorem: ENNReal.mul_le_iff_le_inv
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [← @ENNReal.mul_le_mul_left _ a _ hr₀ hr₁, ← mul_assoc, ENNReal.mul_inv_cancel hr₀ hr₁,
  one_mul]
state_before: a✝ b✝ c d : ℝ≥0∞
r✝ p q : ℝ≥0
a b r : ℝ≥0∞
hr₀ : r ≠ 0
hr₁ : r ≠ ⊤
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
state_after: no goals
Theorem: InnerProductGeometry.inner_eq_mul_norm_of_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: simp [← cos_angle_mul_norm_mul_norm, h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
h : angle x y = 0
⊢ ⟪x, y⟫_ℝ = ‖x‖ * ‖y‖
state_after: no goals
Theorem: Complex.cos_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [arg]
state_before: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos x.arg = x.re / abs x
state_after: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.re / abs x

tactic: split_ifs with h₁ h₂
state_before: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.re / abs x
state_after: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : 0 ≤ x.re
⊢ Real.cos (Real.arcsin (x.im / abs x)) = x.re / abs x

case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : 0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) + π) = x.re / abs x

case neg
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : ¬0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) - π) = x.re / abs x

tactic: rw [Real.cos_arcsin]
state_before: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : 0 ≤ x.re
⊢ Real.cos (Real.arcsin (x.im / abs x)) = x.re / abs x
state_after: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : 0 ≤ x.re
⊢ √(1 - (x.im / abs x) ^ 2) = x.re / abs x

tactic: field_simp [Real.sqrt_sq, (abs.pos hx).le, *]
state_before: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : 0 ≤ x.re
⊢ √(1 - (x.im / abs x) ^ 2) = x.re / abs x
state_after: no goals

tactic: rw [Real.cos_add_pi, Real.cos_arcsin]
state_before: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : 0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) + π) = x.re / abs x
state_after: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : 0 ≤ x.im
⊢ -√(1 - ((-x).im / abs x) ^ 2) = x.re / abs x

tactic: field_simp [Real.sqrt_div (sq_nonneg _), Real.sqrt_sq_eq_abs,
  _root_.abs_of_neg (not_le.1 h₁), *]
state_before: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : 0 ≤ x.im
⊢ -√(1 - ((-x).im / abs x) ^ 2) = x.re / abs x
state_after: no goals

tactic: rw [Real.cos_sub_pi, Real.cos_arcsin]
state_before: case neg
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : ¬0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) - π) = x.re / abs x
state_after: case neg
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : ¬0 ≤ x.im
⊢ -√(1 - ((-x).im / abs x) ^ 2) = x.re / abs x

tactic: field_simp [Real.sqrt_div (sq_nonneg _), Real.sqrt_sq_eq_abs,
  _root_.abs_of_neg (not_le.1 h₁), *]
state_before: case neg
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : ¬0 ≤ x.im
⊢ -√(1 - ((-x).im / abs x) ^ 2) = x.re / abs x
state_after: no goals
Theorem: tprod_comm'
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

tactic: erw [← tprod_prod' h h₁, ← tprod_prod' h.prod_symm h₂,
    ← (Equiv.prodComm γ β).tprod_eq (uncurry f)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (c : γ) (b : β), f b c = ∏' (b : β) (c : γ), f b c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (p : γ × β), uncurry f p.swap = ∏' (c : γ × β), uncurry f ((Equiv.prodComm γ β) c)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (p : γ × β), uncurry f p.swap = ∏' (c : γ × β), uncurry f ((Equiv.prodComm γ β) c)
state_after: no goals