1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: InnerProductGeometry.angle_add_eq_arctan_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle_add_eq_arcsin_of_inner_eq_zero h (Or.inl h0), Real.arctan_eq_arcsin, ←
  div_mul_eq_div_div, norm_add_eq_sqrt_iff_real_inner_eq_zero.2 h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x + y) = Real.arctan (‖y‖ / ‖x‖)
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ Real.arcsin (‖y‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)) = Real.arcsin (‖y‖ / (‖x‖ * √(1 + (‖y‖ / ‖x‖) ^ 2)))

tactic: nth_rw 3 [← Real.sqrt_sq (norm_nonneg x)]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ Real.arcsin (‖y‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)) = Real.arcsin (‖y‖ / (‖x‖ * √(1 + (‖y‖ / ‖x‖) ^ 2)))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ Real.arcsin (‖y‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)) = Real.arcsin (‖y‖ / (√(‖x‖ ^ 2) * √(1 + (‖y‖ / ‖x‖) ^ 2)))

tactic: rw_mod_cast [← Real.sqrt_mul (sq_nonneg _), div_pow, pow_two, pow_two, mul_add, mul_one, mul_div,
  mul_comm (‖x‖ * ‖x‖), ← mul_div, div_self (mul_self_pos.2 (norm_ne_zero_iff.2 h0)).ne', mul_one]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ Real.arcsin (‖y‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)) = Real.arcsin (‖y‖ / (√(‖x‖ ^ 2) * √(1 + (‖y‖ / ‖x‖) ^ 2)))
state_after: no goals
Theorem: CategoryTheory.Equivalence.inverse_counitInv_comp
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [Iso.inv_eq_inv (e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y))
    (Iso.refl _)]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ (e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y)).hom =
    (Iso.refl ((𝟭 C).obj (e.inverse.obj Y))).hom

tactic: exact e.unit_inverse_comp Y
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ (e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y)).hom =
    (Iso.refl ((𝟭 C).obj (e.inverse.obj Y))).hom
state_after: no goals
Theorem: Matrix.vecMul_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext i
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✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : IsScalarTower R S S
M : Matrix n m S
b : R
v : n → S
⊢ (b • v) ᵥ* M = b • v ᵥ* M
state_after: case h
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✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : IsScalarTower R S S
M : Matrix n m S
b : R
v : n → S
i : m
⊢ ((b • v) ᵥ* M) i = (b • v ᵥ* M) i

tactic: simp only [vecMul, dotProduct, Finset.smul_sum, Pi.smul_apply, smul_mul_assoc]
state_before: case h
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✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : IsScalarTower R S S
M : Matrix n m S
b : R
v : n → S
i : m
⊢ ((b • v) ᵥ* M) i = (b • v ᵥ* M) i
state_after: no goals
Theorem: ofAdd_image_zmultiples_eq_zpowers_ofAdd
File: Mathlib/Algebra/Group/Subgroup/ZPowers.lean

tactic: symm
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
x : A
⊢ ⇑Multiplicative.ofAdd '' ↑(AddSubgroup.zmultiples x) = ↑(Subgroup.zpowers (Multiplicative.ofAdd x))
state_after: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
x : A
⊢ ↑(Subgroup.zpowers (Multiplicative.ofAdd x)) = ⇑Multiplicative.ofAdd '' ↑(AddSubgroup.zmultiples x)

tactic: rw [Equiv.eq_image_iff_symm_image_eq]
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
x : A
⊢ ↑(Subgroup.zpowers (Multiplicative.ofAdd x)) = ⇑Multiplicative.ofAdd '' ↑(AddSubgroup.zmultiples x)
state_after: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
x : A
⊢ ⇑Multiplicative.ofAdd.symm '' ↑(Subgroup.zpowers (Multiplicative.ofAdd x)) = ↑(AddSubgroup.zmultiples x)

tactic: exact ofMul_image_zpowers_eq_zmultiples_ofMul
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
x : A
⊢ ⇑Multiplicative.ofAdd.symm '' ↑(Subgroup.zpowers (Multiplicative.ofAdd x)) = ↑(AddSubgroup.zmultiples x)
state_after: no goals
Theorem: MeasureTheory.Measure.IsEverywherePos.smul_measure
File: Mathlib/MeasureTheory/Measure/EverywherePos.lean

tactic: simpa [hc.bot_lt, hs x hx n hn] using hc.bot_lt
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
c : ℝ≥0∞
hc : c ≠ 0
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
⊢ 0 < (c • μ) n
state_after: no goals
Theorem: Real.arccos_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: unfold arccos
state_before: x✝ y x : ℝ
⊢ 0 ≤ arccos x
state_after: x✝ y x : ℝ
⊢ 0 ≤ π / 2 - arcsin x

tactic: linarith [arcsin_le_pi_div_two x]
state_before: x✝ y x : ℝ
⊢ 0 ≤ π / 2 - arcsin x
state_after: no goals
Theorem: card_le_of_surjective
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ⇑f
⊢ Fintype.card β ≤ Fintype.card α
state_after: R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card β ≤ Fintype.card α

tactic: let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card β ≤ Fintype.card α
state_after: R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card β ≤ Fintype.card α

tactic: exact
  le_of_fin_surjective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
    (((LinearEquiv.symm Q).surjective.comp i).comp (LinearEquiv.surjective P))
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card β ≤ Fintype.card α
state_after: no goals
Theorem: Complex.HadamardThreeLines.interpStrip_eq_of_pos
File: Mathlib/Analysis/Complex/Hadamard.lean

tactic: simp only [ne_of_gt h0, ne_of_gt h1, interpStrip, if_false, or_false]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
h0 : 0 < sSupNormIm f 0
h1 : 0 < sSupNormIm f 1
⊢ interpStrip f z = ↑(sSupNormIm f 0) ^ (1 - z) * ↑(sSupNormIm f 1) ^ z
state_after: no goals
Theorem: semilatticeSup_mk'_partialOrder_eq_semilatticeInf_mk'_partialOrder
File: Mathlib/Order/Lattice.lean

tactic: rw [← h, inf_comm, inf_sup_self]
state_before: α✝ : Type u
β : Type v
α : Type u_1
inst✝¹ : Sup α
inst✝ : Inf α
sup_comm : ∀ (a b : α), a ⊔ b = b ⊔ a
sup_assoc : ∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)
sup_idem : ∀ (a : α), a ⊔ a = a
inf_comm : ∀ (a b : α), a ⊓ b = b ⊓ a
inf_assoc : ∀ (a b c : α), a ⊓ b ⊓ c = a ⊓ (b ⊓ c)
inf_idem : ∀ (a : α), a ⊓ a = a
sup_inf_self : ∀ (a b : α), a ⊔ a ⊓ b = a
inf_sup_self : ∀ (a b : α), a ⊓ (a ⊔ b) = a
a b : α
h : a ⊔ b = b
⊢ b ⊓ a = a
state_after: no goals

tactic: rw [← h, sup_comm, sup_inf_self]
state_before: α✝ : Type u
β : Type v
α : Type u_1
inst✝¹ : Sup α
inst✝ : Inf α
sup_comm : ∀ (a b : α), a ⊔ b = b ⊔ a
sup_assoc : ∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)
sup_idem : ∀ (a : α), a ⊔ a = a
inf_comm : ∀ (a b : α), a ⊓ b = b ⊓ a
inf_assoc : ∀ (a b c : α), a ⊓ b ⊓ c = a ⊓ (b ⊓ c)
inf_idem : ∀ (a : α), a ⊓ a = a
sup_inf_self : ∀ (a b : α), a ⊔ a ⊓ b = a
inf_sup_self : ∀ (a b : α), a ⊓ (a ⊔ b) = a
a b : α
h : b ⊓ a = a
⊢ a ⊔ b = b
state_after: no goals
Theorem: Traversable.toList_spec
File: Mathlib/Control/Fold.lean

tactic: simp only [List.reverse_reverse]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ FreeMonoid.toList (foldMap FreeMonoid.of xs) = FreeMonoid.toList (List.reverse (foldMap FreeMonoid.of xs)).reverse
state_after: no goals

tactic: simp only [List.foldr_eta]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ FreeMonoid.toList (List.reverse (foldMap FreeMonoid.of xs)).reverse =
    FreeMonoid.toList (List.foldr cons [] (List.reverse (foldMap FreeMonoid.of xs))).reverse
state_after: no goals

tactic: simp [Function.flip_def, List.foldr_reverse, Foldl.ofFreeMonoid, unop_op]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ FreeMonoid.toList (List.foldr cons [] (List.reverse (foldMap FreeMonoid.of xs))).reverse =
    (unop ((Foldl.ofFreeMonoid (flip cons)) (foldMap FreeMonoid.of xs)) []).reverse
state_after: no goals

tactic: rw [foldMap_hom_free (Foldl.ofFreeMonoid (flip <| @cons α))]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ (unop ((Foldl.ofFreeMonoid (flip cons)) (foldMap FreeMonoid.of xs)) []).reverse = toList xs
state_after: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ (unop (foldMap (⇑(Foldl.ofFreeMonoid (flip cons)) ∘ FreeMonoid.of) xs) []).reverse = toList xs

tactic: simp only [toList, foldl, List.reverse_inj, Foldl.get, foldl.ofFreeMonoid_comp_of,
  Function.comp_apply]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ (unop (foldMap (⇑(Foldl.ofFreeMonoid (flip cons)) ∘ FreeMonoid.of) xs) []).reverse = toList xs
state_after: no goals
Theorem: Tropical.add_eq_right_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
⊢ x + y = y ↔ y ≤ x
state_after: no goals
Theorem: Set.Ioc_diff_right
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp [and_assoc, ← lt_iff_le_and_ne]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c x : α
⊢ x ∈ Ioc a b \ {b} ↔ x ∈ Ioo a b
state_after: no goals
Theorem: Finsupp.card_support_eq_one
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [card_eq_one, support_eq_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
f : α →₀ M
⊢ f.support.card = 1 ↔ ∃ a, f a ≠ 0 ∧ f = single a (f a)
state_after: no goals
Theorem: ZMod.intCast_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

tactic: constructor
state_before: p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z ↔ ∃ k, n = ↑z.val + ↑p * k
state_after: case mp
p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = ↑z.val + ↑p * k

case mpr
p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = ↑z.val + ↑p * k) → ↑n = z

tactic: rintro rfl
state_before: case mp
p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = ↑z.val + ↑p * k
state_after: case mp
p : ℕ
n : ℤ
inst✝ : NeZero p
⊢ ∃ k, n = ↑(↑n).val + ↑p * k

tactic: refine ⟨n / p, ?_⟩
state_before: case mp
p : ℕ
n : ℤ
inst✝ : NeZero p
⊢ ∃ k, n = ↑(↑n).val + ↑p * k
state_after: case mp
p : ℕ
n : ℤ
inst✝ : NeZero p
⊢ n = ↑(↑n).val + ↑p * (n / ↑p)

tactic: rw [val_intCast, Int.emod_add_ediv]
state_before: case mp
p : ℕ
n : ℤ
inst✝ : NeZero p
⊢ n = ↑(↑n).val + ↑p * (n / ↑p)
state_after: no goals

tactic: rintro ⟨k, rfl⟩
state_before: case mpr
p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = ↑z.val + ↑p * k) → ↑n = z
state_after: case mpr.intro
p : ℕ
z : ZMod p
inst✝ : NeZero p
k : ℤ
⊢ ↑(↑z.val + ↑p * k) = z

tactic: rw [Int.cast_add, Int.cast_mul, Int.cast_natCast, Int.cast_natCast, natCast_val,
  ZMod.natCast_self, zero_mul, add_zero, cast_id]
state_before: case mpr.intro
p : ℕ
z : ZMod p
inst✝ : NeZero p
k : ℤ
⊢ ↑(↑z.val + ↑p * k) = z
state_after: no goals
Theorem: Vector.scanl_singleton
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [← cons_head_tail v]
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v✝ : Vector α n
v : Vector α 1
⊢ scanl f b v = b ::ᵥ f b v.head ::ᵥ nil
state_after: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v✝ : Vector α n
v : Vector α 1
⊢ scanl f b (v.head ::ᵥ v.tail) = b ::ᵥ f b (v.head ::ᵥ v.tail).head ::ᵥ nil

tactic: simp only [scanl_cons, scanl_nil, head_cons, singleton_tail]
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v✝ : Vector α n
v : Vector α 1
⊢ scanl f b (v.head ::ᵥ v.tail) = b ::ᵥ f b (v.head ::ᵥ v.tail).head ::ᵥ nil
state_after: no goals
Theorem: Profinite.finiteCoproduct.hom_ext
File: Mathlib/Topology/Category/Profinite/Limits.lean

tactic: ext ⟨a, x⟩
state_before: α : Type w
inst✝ : Finite α
X : α → Profinite
B : Profinite
f g : finiteCoproduct X ⟶ B
h : ∀ (a : α), ι X a ≫ f = ι X a ≫ g
⊢ f = g
state_after: case w.mk
α : Type w
inst✝ : Finite α
X : α → Profinite
B : Profinite
f g : finiteCoproduct X ⟶ B
h : ∀ (a : α), ι X a ≫ f = ι X a ≫ g
a : α
x : ↑(X a).toCompHaus.toTop
⊢ f ⟨a, x⟩ = g ⟨a, x⟩

tactic: specialize h a
state_before: case w.mk
α : Type w
inst✝ : Finite α
X : α → Profinite
B : Profinite
f g : finiteCoproduct X ⟶ B
h : ∀ (a : α), ι X a ≫ f = ι X a ≫ g
a : α
x : ↑(X a).toCompHaus.toTop
⊢ f ⟨a, x⟩ = g ⟨a, x⟩
state_after: case w.mk
α : Type w
inst✝ : Finite α
X : α → Profinite
B : Profinite
f g : finiteCoproduct X ⟶ B
a : α
x : ↑(X a).toCompHaus.toTop
h : ι X a ≫ f = ι X a ≫ g
⊢ f ⟨a, x⟩ = g ⟨a, x⟩

tactic: exact h
state_before: case w.mk
α : Type w
inst✝ : Finite α
X : α → Profinite
B : Profinite
f g : finiteCoproduct X ⟶ B
a : α
x : ↑(X a).toCompHaus.toTop
h : (ι X a ≫ f) x = (ι X a ≫ g) x
⊢ f ⟨a, x⟩ = g ⟨a, x⟩
state_after: no goals
Theorem: EuclideanGeometry.oangle_eq_zero_or_eq_pi_iff_collinear
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: rw [← not_iff_not, not_or, oangle_ne_zero_and_ne_pi_iff_affineIndependent,
  affineIndependent_iff_not_collinear_set]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ ∡ p₁ p₂ p₃ = 0 ∨ ∡ p₁ p₂ p₃ = ↑π ↔ Collinear ℝ {p₁, p₂, p₃}
state_after: no goals
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_of_adj
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: rw [← h.of_adj v w ha]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - ℓ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)

tactic: apply h.card_neighborFinset_union_eq
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: no goals
Theorem: Filter.limsup_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [limsup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : β → α
⊢ limsup f ⊥ = ⊥
state_after: no goals
Theorem: Real.sin_sq_pi_over_two_pow_succ
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sin_sq_pi_over_two_pow, sqrtTwoAddSeries, div_pow, sq_sqrt, add_div, ← sub_sub]
state_before: x : ℝ
n : ℕ
⊢ sin (π / 2 ^ (n + 2)) ^ 2 = 1 / 2 - sqrtTwoAddSeries 0 n / 4
state_after: x : ℝ
n : ℕ
⊢ 1 - 2 / 2 ^ 2 - sqrtTwoAddSeries 0 n / 2 ^ 2 = 1 / 2 - sqrtTwoAddSeries 0 n / 4

x : ℝ
n : ℕ
⊢ 0 ≤ 2 + sqrtTwoAddSeries 0 n

tactic: congr
state_before: x : ℝ
n : ℕ
⊢ 1 - 2 / 2 ^ 2 - sqrtTwoAddSeries 0 n / 2 ^ 2 = 1 / 2 - sqrtTwoAddSeries 0 n / 4
state_after: case e_a
x : ℝ
n : ℕ
⊢ 1 - 2 / 2 ^ 2 = 1 / 2

case e_a.e_a
x : ℝ
n : ℕ
⊢ 2 ^ 2 = 4

tactic: norm_num
state_before: case e_a
x : ℝ
n : ℕ
⊢ 1 - 2 / 2 ^ 2 = 1 / 2
state_after: no goals

tactic: norm_num
state_before: case e_a.e_a
x : ℝ
n : ℕ
⊢ 2 ^ 2 = 4
state_after: no goals

tactic: exact add_nonneg two_pos.le (sqrtTwoAddSeries_zero_nonneg _)
state_before: x : ℝ
n : ℕ
⊢ 0 ≤ 2 + sqrtTwoAddSeries 0 n
state_after: no goals
Theorem: Polynomial.isUnit_iff_degree_eq_zero
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: simp [*, le_refl]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : p.degree = 0
⊢ p.degree ≤ 0
state_after: no goals

tactic: rw [eq_C_of_degree_le_zero this, hc] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : (C 0).degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False

tactic: simp only [map_zero] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : (C 0).degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
this : p.degree ≤ 0
hc : p.coeff 0 = 0
h : degree 0 = 0
⊢ False

tactic: contradiction
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
this : p.degree ≤ 0
hc : p.coeff 0 = 0
h : degree 0 = 0
⊢ False
state_after: no goals

tactic: conv in p => rw [eq_C_of_degree_le_zero this]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = p * C (p.coeff 0)⁻¹
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = C (p.coeff 0) * C (p.coeff 0)⁻¹

tactic: rw [← C_mul, _root_.mul_inv_cancel hc, C_1]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = C (p.coeff 0) * C (p.coeff 0)⁻¹
state_after: no goals
Theorem: Lagrange.interpolate_one
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [interpolate_apply, Pi.one_apply, map_one, one_mul]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ (interpolate s v) 1 = 1
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ x ∈ s, Lagrange.basis s v x = 1

tactic: exact sum_basis hvs hs
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ x ∈ s, Lagrange.basis s v x = 1
state_after: no goals
Theorem: LieSubmodule.comap_incl_self
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
⊢ comap N.incl N = ⊤
state_after: no goals
Theorem: Module.Ray.neg_units_smul
File: Mathlib/LinearAlgebra/Ray.lean

tactic: induction v using Module.Ray.ind
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
u : Rˣ
v : Ray R M
⊢ -u • v = -(u • v)
state_after: case h
R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
u : Rˣ
v✝ : M
hv✝ : v✝ ≠ 0
⊢ -u • rayOfNeZero R v✝ hv✝ = -(u • rayOfNeZero R v✝ hv✝)

tactic: simp only [smul_rayOfNeZero, Units.smul_def, Units.val_neg, neg_smul, neg_rayOfNeZero]
state_before: case h
R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
u : Rˣ
v✝ : M
hv✝ : v✝ ≠ 0
⊢ -u • rayOfNeZero R v✝ hv✝ = -(u • rayOfNeZero R v✝ hv✝)
state_after: no goals
Theorem: LinearMap.iterate_succ
File: Mathlib/Algebra/Module/LinearMap/End.lean

tactic: rw [pow_succ, mul_eq_comp]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
S : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
N₁ : Type u_10
N₂ : Type u_11
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommGroup N₁
inst✝⁴ : Module R M
inst✝³ : Module R N₁
inst✝² : Monoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass R S M
f' : M →ₗ[R] M
n : ℕ
⊢ f' ^ (n + 1) = (f' ^ n) ∘ₗ f'
state_after: no goals
Theorem: mul_sub_one
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [mul_sub, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ a * (b - 1) = a * b - a
state_after: no goals
Theorem: continuousMap_mem_polynomialFunctions_closure
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

tactic: rw [polynomialFunctions_closure_eq_top _ _]
state_before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ (polynomialFunctions (Set.Icc a b)).topologicalClosure
state_after: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤

tactic: simp
state_before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤
state_after: no goals
Theorem: FirstOrder.Field.realize_eqZero
File: Mathlib/ModelTheory/Algebra/Field/CharP.lean

tactic: simp [eqZero, Term.realize]
state_before: p : ℕ
K : Type u_1
inst✝¹ : CommRing K
inst✝ : CompatibleRing K
n : ℕ
v : Empty → K
⊢ Formula.Realize (eqZero n) v ↔ ↑n = 0
state_after: no goals