tasksource/leandojo huggingface dataset:
Theorem: Matrix.dotProduct_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type ?u.176069
m : Type u_1
n : Type ?u.176075
o : Type ?u.176078
m' : o → Type ?u.176083
n' : o → Type ?u.176088
R : Type ?u.176091
S : Type ?u.176094
α : Type v
β : Type w
γ : Type ?u.176101
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ v ⬝ᵥ -w = -(v ⬝ᵥ w)
Theorem: SubgroupClass.coeSubtype
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rfl
state_before: G : Type u_1
G' : Type ?u.40251
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.40260
inst✝⁴ : AddGroup A
M : Type ?u.40266
S : Type u_2
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
⊢ ↑↑H = Subtype.val
Theorem: MeasureTheory.union_ae_eq_left_of_ae_eq_empty
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: convert ae_eq_set_union (ae_eq_refl s) h
state_before: α : Type u_1
β : Type ?u.120104
γ : Type ?u.120107
δ : Type ?u.120110
ι : Type ?u.120113
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] ∅
⊢ s ∪ t =ᵐ[μ] s

tactic: rw [union_empty]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.120104
γ : Type ?u.120107
δ : Type ?u.120110
ι : Type ?u.120113
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] ∅
⊢ s = s ∪ ∅
Theorem: TrivSqZeroExt.exp_inl
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: rw [exp_def_of_smul_comm, snd_inl, fst_inl, smul_zero, inr_zero, add_zero]
state_before: 𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁷ : IsROrC 𝕜
inst✝¹⁶ : NormedRing R
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : NormedAlgebra 𝕜 R
inst✝¹³ : Module R M
inst✝¹² : Module Rᵐᵒᵖ M
inst✝¹¹ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁰ : Module 𝕜 M
inst✝⁹ : IsScalarTower 𝕜 R M
inst✝⁸ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : ContinuousSMul Rᵐᵒᵖ M
inst✝² : CompleteSpace R
inst✝¹ : T2Space R
inst✝ : T2Space M
x : R
⊢ exp 𝕜 (inl x) = inl (exp 𝕜 x)

tactic: rw [snd_inl, fst_inl, smul_zero, smul_zero]
state_before: case hx
𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁷ : IsROrC 𝕜
inst✝¹⁶ : NormedRing R
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : NormedAlgebra 𝕜 R
inst✝¹³ : Module R M
inst✝¹² : Module Rᵐᵒᵖ M
inst✝¹¹ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁰ : Module 𝕜 M
inst✝⁹ : IsScalarTower 𝕜 R M
inst✝⁸ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : ContinuousSMul Rᵐᵒᵖ M
inst✝² : CompleteSpace R
inst✝¹ : T2Space R
inst✝ : T2Space M
x : R
⊢ MulOpposite.op (fst (inl x)) • snd (inl x) = fst (inl x) • snd (inl x)
Theorem: Real.IsConjugateExponent.one_lt_nnreal
File: Mathlib/Data/Real/ConjugateExponents.lean

tactic: rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ 1 < toNNReal p

tactic: exact h.one_lt
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ 1 < p
Theorem: PEquiv.trans_bot
File: Mathlib/Data/PEquiv.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ PEquiv.trans f ⊥ = ⊥

tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ ↑(PEquiv.trans f ⊥) x✝ ↔ a✝ ∈ ↑⊥ x✝

tactic: simp
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ Option.bind (↑f x✝) ↑⊥ ↔ a✝ ∈ none
Theorem: Finset.weightedVSubOfPoint_erase
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.47297
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ ↑(weightedVSubOfPoint (erase s i) p (p i)) w = ↑(weightedVSubOfPoint s p (p i)) w

tactic: apply sum_erase
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.47297
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ ∑ i_1 in erase s i, w i_1 • (p i_1 -ᵥ p i) = ∑ i_1 in s, w i_1 • (p i_1 -ᵥ p i)

tactic: rw [vsub_self, smul_zero]
state_before: case h
k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.47297
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ w i • (p i -ᵥ p i) = 0
Theorem: Multiset.card_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.22821
δ : Type ?u.22824
a : α
s t : Multiset α
f g : α → Multiset β
⊢ ↑card (bind s f) = sum (map (↑card ∘ f) s)
Theorem: Monoid.exponent_eq_max'_orderOf
File: Mathlib/GroupTheory/Exponent.lean

tactic: simp
state_before: G : Type u
inst✝¹ : CancelCommMonoid G
inst✝ : Fintype G
⊢ 1 ∈ Finset.image orderOf Finset.univ

tactic: rw [← Finset.Nonempty.cSup_eq_max', Finset.coe_image, Finset.coe_univ, Set.image_univ, ← iSup]
state_before: G : Type u
inst✝¹ : CancelCommMonoid G
inst✝ : Fintype G
⊢ exponent G = Finset.max' (Finset.image orderOf Finset.univ) (_ : ∃ x, x ∈ Finset.image orderOf Finset.univ)

tactic: exact exponent_eq_iSup_orderOf orderOf_pos
state_before: G : Type u
inst✝¹ : CancelCommMonoid G
inst✝ : Fintype G
⊢ exponent G = iSup orderOf
Theorem: Zspan.exist_unique_vadd_mem_fundamentalDomain
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: cases nonempty_fintype ι
state_before: E : Type u_2
ι : Type u_1
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Finite ι
x : E
⊢ ∃! v, v +ᵥ x ∈ fundamentalDomain b

tactic: refine ⟨-floor b x, ?_, fun y h => ?_⟩
state_before: case intro
E : Type u_2
ι : Type u_1
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Finite ι
x : E
val✝ : Fintype ι
⊢ ∃! v, v +ᵥ x ∈ fundamentalDomain b

tactic: exact (vadd_mem_fundamentalDomain b (-floor b x) x).mpr rfl
state_before: case intro.refine_1
E : Type u_2
ι : Type u_1
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Finite ι
x : E
val✝ : Fintype ι
⊢ (fun v => v +ᵥ x ∈ fundamentalDomain b) (-floor b x)

tactic: exact (vadd_mem_fundamentalDomain b y x).mp h
state_before: case intro.refine_2
E : Type u_2
ι : Type u_1
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Finite ι
x : E
val✝ : Fintype ι
y : { x // x ∈ span ℤ (Set.range ↑b) }
h : (fun v => v +ᵥ x ∈ fundamentalDomain b) y
⊢ y = -floor b x
Theorem: Finset.map_nonempty
File: Mathlib/Data/Finset/Image.lean

tactic: rw [nonempty_iff_ne_empty, nonempty_iff_ne_empty, Ne.def, map_eq_empty]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.45024
f : α ↪ β
s : Finset α
⊢ Finset.Nonempty (map f s) ↔ Finset.Nonempty s
Theorem: Finsupp.domLCongr_single
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp
state_before: α : Type ?u.477990
M : Type u_3
N : Type ?u.477996
P : Type ?u.477999
R : Type u_4
S : Type ?u.478005
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α₁ : Type u_1
α₂ : Type u_2
e : α₁ ≃ α₂
i : α₁
m : M
⊢ ↑(Finsupp.domLCongr e) (single i m) = single (↑e i) m
Theorem: Int.add_emod
File: Std/Data/Int/DivMod.lean

tactic: rw [add_emod_emod, emod_add_emod]
state_before: a b n : Int
⊢ (a + b) % n = (a % n + b % n) % n
Theorem: Cardinal.mk_coe_finset
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α✝ β α : Type u
s : Finset α
⊢ (#{ x // x ∈ s }) = ↑(Finset.card s)
Theorem: PiTensorProduct.reindex_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

tactic: dsimp [reindex]
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type ?u.429705
R : Type u_3
inst✝⁷ : CommSemiring R
R₁ : Type ?u.429714
R₂ : Type ?u.429717
s : ι → Type ?u.429722
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_4
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type ?u.430041
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.430175
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
e : ι ≃ ι₂
f : ι → M
⊢ ↑(reindex R M e) (↑(tprod R) f) = ⨂ₜ[R] (i : ι₂), f (↑e.symm i)

tactic: exact liftAux_tprod _ f
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type ?u.429705
R : Type u_3
inst✝⁷ : CommSemiring R
R₁ : Type ?u.429714
R₂ : Type ?u.429717
s : ι → Type ?u.429722
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_4
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type ?u.430041
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.430175
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
e : ι ≃ ι₂
f : ι → M
⊢ ↑(↑lift (domDomCongr e.symm (tprod R))) (↑(tprod R) f) = ⨂ₜ[R] (i : ι₂), f (↑e.symm i)
Theorem: Matrix.eq_zero_of_mulVec_eq_zero
File: Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean

tactic: rwa [det_transpose]
state_before: m : Type u_1
R : Type ?u.18430
A : Type u_2
inst✝⁴ : Fintype m
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : DecidableEq m
M : Matrix m m A
hM : det M ≠ 0
v : m → A
hv : mulVec M v = 0
⊢ det Mᵀ ≠ 0
Theorem: Prod.mk.inj_right
File: Mathlib/Data/Prod/Basic.lean

tactic: intro b₁ b₂ h
state_before: α✝ : Type ?u.2461
β✝ : Type ?u.2464
γ : Type ?u.2467
δ : Type ?u.2470
α : Type u_1
β : Type u_2
b : β
⊢ Function.Injective fun a => (a, b)

tactic: simpa only [and_true, eq_self_iff_true, mk.inj_iff] using h
state_before: α✝ : Type ?u.2461
β✝ : Type ?u.2464
γ : Type ?u.2467
δ : Type ?u.2470
α : Type u_1
β : Type u_2
b : β
b₁ b₂ : α
h : (fun a => (a, b)) b₁ = (fun a => (a, b)) b₂
⊢ b₁ = b₂
Theorem: IsGroupHom.image_subgroup
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [eq₁, eq₂, hf.map_mul]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.86268
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a₁ a₂ : H
x✝¹ : a₁ ∈ f '' s
x✝ : a₂ ∈ f '' s
b₁ : G
hb₁ : b₁ ∈ s
eq₁ : f b₁ = a₁
b₂ : G
hb₂ : b₂ ∈ s
eq₂ : f b₂ = a₂
⊢ f (b₁ * b₂) = a₁ * a₂

tactic: rw [hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.86268
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ f b⁻¹ = a⁻¹

tactic: simp [*]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.86268
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
Theorem: CstarRing.norm_self_mul_star
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: nth_rw 1 [← star_star x]
state_before: 𝕜 : Type ?u.32816
E : Type u_1
α : Type ?u.32822
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ ‖x * x⋆‖ = ‖x‖ * ‖x‖

tactic: simp only [norm_star_mul_self, norm_star]
state_before: 𝕜 : Type ?u.32816
E : Type u_1
α : Type ?u.32822
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ ‖x⋆⋆ * x⋆‖ = ‖x‖ * ‖x‖
Theorem: WithOne.map_id
File: Mathlib/Algebra/Group/WithOne/Basic.lean

tactic: ext x
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Mul α
inst✝¹ : Mul β
inst✝ : Mul γ
⊢ map (MulHom.id α) = MonoidHom.id (WithOne α)

tactic: induction x using WithOne.cases_on <;> rfl
state_before: case h
α : Type u
β : Type v
γ : Type w
inst✝² : Mul α
inst✝¹ : Mul β
inst✝ : Mul γ
x : WithOne α
⊢ ↑(map (MulHom.id α)) x = ↑(MonoidHom.id (WithOne α)) x
Theorem: Denumerable.prod_nat_ofNat
File: Mathlib/Logic/Denumerable.lean

tactic: funext
state_before: α : Type ?u.32247
β : Type ?u.32250
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ofNat (ℕ × ℕ) = unpair

tactic: simp
state_before: case h
α : Type ?u.32247
β : Type ?u.32250
inst✝¹ : Denumerable α
inst✝ : Denumerable β
x✝ : ℕ
⊢ ofNat (ℕ × ℕ) x✝ = unpair x✝
Theorem: CategoryTheory.Limits.kernel_map_comp_preserves_kernel_iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

tactic: rw [← G.map_comp, hpq, G.map_comp]
state_before: C : Type u₁
inst✝¹⁰ : Category C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝⁵ : HasKernel f
inst✝⁴ : HasKernel (G.map f)
inst✝³ : PreservesLimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasKernel g
inst✝¹ : HasKernel (G.map g)
inst✝ : PreservesLimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g

tactic: rw [Iso.comp_inv_eq, Category.assoc, PreservesKernel.iso_hom, Iso.eq_inv_comp,
  PreservesKernel.iso_hom, kernelComparison_comp_kernel_map]
state_before: C : Type u₁
inst✝¹⁰ : Category C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms G
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝⁵ : HasKernel f
inst✝⁴ : HasKernel (G.map f)
inst✝³ : PreservesLimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasKernel g
inst✝¹ : HasKernel (G.map g)
inst✝ : PreservesLimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ kernel.map (G.map f) (G.map g) (G.map p) (G.map q) (_ : G.map f ≫ G.map q = G.map p ≫ G.map g) ≫
      (PreservesKernel.iso G g).inv =
    (PreservesKernel.iso G f).inv ≫ G.map (kernel.map f g p q hpq)
Theorem: Nat.Odd.sub_odd
File: Mathlib/Data/Nat/Parity.lean

tactic: simp only [even_sub' h, *]
state_before: m n : ℕ
hm : Odd m
hn : Odd n
h : n ≤ m
⊢ Even (m - n)

tactic: simp only [tsub_eq_zero_iff_le.mpr h, even_zero]
state_before: m n : ℕ
hm : Odd m
hn : Odd n
h : m ≤ n
⊢ Even (m - n)
Theorem: Nat.Prime.dvd_factorial
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [factorial_succ, hp.dvd_mul, Prime.dvd_factorial hp]
state_before: n p : ℕ
hp : Prime p
⊢ p ∣ (n + 1)! ↔ p ≤ n + 1

tactic: exact
  ⟨fun h => h.elim (le_of_dvd (succ_pos _)) le_succ_of_le, fun h =>
    (_root_.lt_or_eq_of_le h).elim (Or.inr ∘ le_of_lt_succ) fun h => Or.inl <| by rw [h]⟩
state_before: n p : ℕ
hp : Prime p
⊢ p ∣ n + 1 ∨ p ≤ n ↔ p ≤ n + 1

tactic: rw [h]
state_before: n p : ℕ
hp : Prime p
h✝ : p ≤ n + 1
h : p = n + 1
⊢ p ∣ n + 1
Theorem: WithBot.unbot'_eq_unbot'_iff
File: Mathlib/Order/WithBot.lean

tactic: induction y using recBotCoe <;> simp [unbot'_eq_iff, or_comm]
state_before: α : Type u_1
β : Type ?u.4891
γ : Type ?u.4894
δ : Type ?u.4897
a b d : α
x y : WithBot α
⊢ unbot' d x = unbot' d y ↔ x = y ∨ x = ↑d ∧ y = ⊥ ∨ x = ⊥ ∧ y = ↑d
Theorem: Polynomial.mem_nthRoots
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [nthRoots, mem_roots (X_pow_sub_C_ne_zero hn a), IsRoot.def, eval_sub, eval_C, eval_pow,
  eval_X, 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]
n : ℕ
hn : 0 < n
a x : R
⊢ x ∈ nthRoots n a ↔ x ^ n = a
Theorem: Configuration.ProjectivePlane.lineCount_eq
File: Mathlib/Combinatorics/Configuration.lean

tactic: classical
  obtain ⟨q, -, -, l, -, -, -, -, h, -⟩ := Classical.choose_spec (@exists_config P L _ _)
  cases nonempty_fintype { l : L // q ∈ l }
  rw [order, lineCount_eq_lineCount L p q, lineCount_eq_lineCount L (Classical.choose _) q,
    lineCount, Nat.card_eq_fintype_card, Nat.sub_add_cancel]
  exact Fintype.card_pos_iff.mpr ⟨⟨l, h⟩⟩
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ lineCount L p = order P L + 1

tactic: obtain ⟨q, -, -, l, -, -, -, -, h, -⟩ := Classical.choose_spec (@exists_config P L _ _)
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ lineCount L p = order P L + 1

tactic: cases nonempty_fintype { l : L // q ∈ l }
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
⊢ lineCount L p = order P L + 1

tactic: rw [order, lineCount_eq_lineCount L p q, lineCount_eq_lineCount L (Classical.choose _) q,
  lineCount, Nat.card_eq_fintype_card, Nat.sub_add_cancel]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ lineCount L p = order P L + 1

tactic: exact Fintype.card_pos_iff.mpr ⟨⟨l, h⟩⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ 1 ≤ Fintype.card { l // q ∈ l }
Theorem: Ideal.span_singleton_mul_left_inj
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [le_antisymm_iff, span_singleton_mul_left_mono hx]
state_before: R : Type u
ι : Type ?u.241212
inst✝¹ : CommSemiring R
I J K L : Ideal R
inst✝ : IsDomain R
x : R
hx : x ≠ 0
⊢ I * span {x} = J * span {x} ↔ I = J
Theorem: StarConvex.linear_preimage
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s✝ : Set E
s : Set F
f : E →ₗ[𝕜] F
hs : StarConvex 𝕜 (↑f x) s
⊢ StarConvex 𝕜 x (↑f ⁻¹' s)

tactic: rw [mem_preimage, f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s✝ : Set E
s : Set F
f : E →ₗ[𝕜] F
hs : StarConvex 𝕜 (↑f x) s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ ↑f ⁻¹' s

tactic: exact hs hy ha hb hab
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s✝ : Set E
s : Set F
f : E →ₗ[𝕜] F
hs : StarConvex 𝕜 (↑f x) s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • ↑f x + b • ↑f y ∈ s
Theorem: AffineBasis.centroid_mem_interior_convexHull
File: Mathlib/Analysis/NormedSpace/AddTorsorBases.lean

tactic: haveI := b.nonempty
state_before: V : Type u_2
P : Type ?u.93147
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ι : Type u_1
inst✝ : Fintype ι
b : AffineBasis ι ℝ V
⊢ Finset.centroid ℝ Finset.univ ↑b ∈ interior (↑(convexHull ℝ).toOrderHom (range ↑b))

tactic: simp only [b.interior_convexHull, mem_setOf_eq, b.coord_apply_centroid (Finset.mem_univ _),
  inv_pos, Nat.cast_pos, Finset.card_pos, Finset.univ_nonempty, forall_true_iff]
state_before: V : Type u_2
P : Type ?u.93147
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ι : Type u_1
inst✝ : Fintype ι
b : AffineBasis ι ℝ V
this : Nonempty ι
⊢ Finset.centroid ℝ Finset.univ ↑b ∈ interior (↑(convexHull ℝ).toOrderHom (range ↑b))
Theorem: Filter.blimsup_or_eq_sup
File: Mathlib/Order/LiminfLimsup.lean

tactic: refine' le_antisymm _ blimsup_sup_le_or
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.162092
ι : Type ?u.162095
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
⊢ (blimsup u f fun x => p x ∨ q x) = blimsup u f p ⊔ blimsup u f q

tactic: simp only [blimsup_eq, sInf_sup_eq, sup_sInf_eq, le_iInf₂_iff, mem_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.162092
ι : Type ?u.162095
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
⊢ (blimsup u f fun x => p x ∨ q x) ≤ blimsup u f p ⊔ blimsup u f q

tactic: refine' fun a' ha' a ha => sInf_le ((ha.and ha').mono fun b h hb => _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.162092
ι : Type ?u.162095
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
⊢ ∀ (i : α),
    (∀ᶠ (x : β) in f, q x → u x ≤ i) →
      ∀ (i_1 : α), (∀ᶠ (x : β) in f, p x → u x ≤ i_1) → sInf {a | ∀ᶠ (x : β) in f, p x ∨ q x → u x ≤ a} ≤ i_1 ⊔ i

tactic: exact Or.elim hb (fun hb => le_sup_of_le_left <| h.1 hb) fun hb => le_sup_of_le_right <| h.2 hb
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.162092
ι : Type ?u.162095
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
a' : α
ha' : ∀ᶠ (x : β) in f, q x → u x ≤ a'
a : α
ha : ∀ᶠ (x : β) in f, p x → u x ≤ a
b : β
h : (p b → u b ≤ a) ∧ (q b → u b ≤ a')
hb : p b ∨ q b
⊢ u b ≤ a ⊔ a'
Theorem: Nat.rel_of_forall_rel_succ_of_le_of_lt
File: Mathlib/Order/Monotone/Basic.lean

tactic: induction' hbc with k b_lt_k r_b_k
state_before: ι : Type ?u.39250
α : Type u
β : Type v
γ : Type w
δ : Type ?u.39259
π : ι → Type ?u.39264
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
hbc : b < c
⊢ r (f b) (f c)

tactic: exacts [h _ hab, _root_.trans r_b_k (h _ (hab.trans_lt b_lt_k).le)]
state_before: case refl
ι : Type ?u.39250
α : Type u
β : Type v
γ : Type w
δ : Type ?u.39259
π : ι → Type ?u.39264
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
⊢ r (f b) (f (succ b))

case step
ι : Type ?u.39250
α : Type u
β : Type v
γ : Type w
δ : Type ?u.39259
π : ι → Type ?u.39264
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
k : ℕ
b_lt_k : Nat.le (succ b) k
r_b_k : r (f b) (f k)
⊢ r (f b) (f (succ k))
Theorem: hasFDerivAt_polarCoord_symm
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

tactic: rw [Matrix.toLin_finTwoProd_toContinuousLinearMap]
state_before: p : ℝ × ℝ
⊢ HasFDerivAt (↑(LocalHomeomorph.symm polarCoord))
    (↑LinearMap.toContinuousLinearMap
      (↑(Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (↑Matrix.of ![![cos p.snd, -p.fst * sin p.snd], ![sin p.snd, p.fst * cos p.snd]])))
    p

tactic: convert HasFDerivAt.prod (𝕜 := ℝ)
  (hasFDerivAt_fst.mul ((hasDerivAt_cos p.2).comp_hasFDerivAt p hasFDerivAt_snd))
  (hasFDerivAt_fst.mul ((hasDerivAt_sin p.2).comp_hasFDerivAt p hasFDerivAt_snd)) using 2 <;>
simp [smul_smul, add_comm, neg_mul, neg_smul, smul_neg]
state_before: p : ℝ × ℝ
⊢ HasFDerivAt (↑(LocalHomeomorph.symm polarCoord))
    (ContinuousLinearMap.prod
      (cos p.snd • ContinuousLinearMap.fst ℝ ℝ ℝ + (-p.fst * sin p.snd) • ContinuousLinearMap.snd ℝ ℝ ℝ)
      (sin p.snd • ContinuousLinearMap.fst ℝ ℝ ℝ + (p.fst * cos p.snd) • ContinuousLinearMap.snd ℝ ℝ ℝ))
    p
Theorem: List.map_map_permutations'Aux
File: Mathlib/Data/List/Permutation.lean

tactic: induction' ts with a ts ih <;> [rfl; (simp [← ih]; rfl)]
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts : List α
⊢ map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)

tactic: simp [← ih]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → β
t a : α
ts : List α
ih : map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)
⊢ map (map f) (permutations'Aux t (a :: ts)) = permutations'Aux (f t) (map f (a :: ts))

tactic: rfl
state_before: case cons
α : Type u_1
β : Type u_2
f : α → β
t a : α
ts : List α
ih : map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)
⊢ map (map f ∘ cons a) (permutations'Aux t ts) = map (cons (f a) ∘ map f) (permutations'Aux t ts)
Theorem: Real.sqrt_eq_iff_mul_self_eq_of_pos
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [sqrt_eq_cases, h.ne', h.le]
state_before: x y : ℝ
h : 0 < y
⊢ sqrt x = y ↔ y * y = x