tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Localization.Construction.natTrans_hcomp_injective
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: ext X
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_4
inst✝ : Category D
G✝ : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
⊢ τ₁ = τ₂

tactic: have eq := (objEquiv W).right_inv X
state_before: case w.h
C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_4
inst✝ : Category D
G✝ : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
⊢ τ₁.app X = τ₂.app X

tactic: simp only [objEquiv] at eq
state_before: case w.h
C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_4
inst✝ : Category D
G✝ : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
eq : Equiv.toFun (objEquiv W) (Equiv.invFun (objEquiv W) X) = X
⊢ τ₁.app X = τ₂.app X

tactic: rw [← eq, ← NatTrans.id_hcomp_app, ← NatTrans.id_hcomp_app, h]
state_before: case w.h
C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_4
inst✝ : Category D
G✝ : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
eq : (MorphismProperty.Q W).obj X.as.obj = X
⊢ τ₁.app X = τ₂.app X
Theorem: LinearMap.isClosed_or_dense_ker
File: Mathlib/Topology/Algebra/Module/Simple.lean

tactic: rcases l.surjective_or_eq_zero with (hl | rfl)
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : ContinuousSMul R M
inst✝² : Module R N
inst✝¹ : ContinuousAdd M
inst✝ : IsSimpleModule R N
l : M →ₗ[R] N
⊢ IsClosed ↑(ker l) ∨ Dense ↑(ker l)

tactic: exact l.ker.isClosed_or_dense_of_isCoatom (LinearMap.isCoatom_ker_of_surjective hl)
state_before: case inl
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : ContinuousSMul R M
inst✝² : Module R N
inst✝¹ : ContinuousAdd M
inst✝ : IsSimpleModule R N
l : M →ₗ[R] N
hl : Function.Surjective ↑l
⊢ IsClosed ↑(ker l) ∨ Dense ↑(ker l)

tactic: rw [LinearMap.ker_zero]
state_before: case inr
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : ContinuousSMul R M
inst✝² : Module R N
inst✝¹ : ContinuousAdd M
inst✝ : IsSimpleModule R N
⊢ IsClosed ↑(ker 0) ∨ Dense ↑(ker 0)

tactic: left
state_before: case inr
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : ContinuousSMul R M
inst✝² : Module R N
inst✝¹ : ContinuousAdd M
inst✝ : IsSimpleModule R N
⊢ IsClosed ↑⊤ ∨ Dense ↑⊤

tactic: exact isClosed_univ
state_before: case inr.h
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : ContinuousSMul R M
inst✝² : Module R N
inst✝¹ : ContinuousAdd M
inst✝ : IsSimpleModule R N
⊢ IsClosed ↑⊤
Theorem: dist_pi_lt_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: lift r to ℝ≥0 using hr.le
state_before: α : Type u
β : Type v
X : Type ?u.391436
ι : Type ?u.391439
inst✝² : PseudoMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
f g : (b : β) → π b
r : ℝ
hr : 0 < r
⊢ dist f g < r ↔ ∀ (b : β), dist (f b) (g b) < r

tactic: simp [dist_pi_def, Finset.sup_lt_iff (show ⊥ < r from hr)]
state_before: case intro
α : Type u
β : Type v
X : Type ?u.391436
ι : Type ?u.391439
inst✝² : PseudoMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
f g : (b : β) → π b
r : ℝ≥0
hr : 0 < ↑r
⊢ dist f g < ↑r ↔ ∀ (b : β), dist (f b) (g b) < ↑r
Theorem: continuousAt_congr
File: Mathlib/Topology/Basic.lean

tactic: simp only [ContinuousAt, tendsto_congr' h, h.eq_of_nhds]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.165904
δ : Type ?u.165907
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f g : α → β
x : α
h : f =ᶠ[𝓝 x] g
⊢ ContinuousAt f x ↔ ContinuousAt g x
Theorem: SimpleGraph.chromaticNumber_le_of_colorable
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: rw [chromaticNumber]
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
n : ℕ
hc : Colorable G n
⊢ chromaticNumber G ≤ n

tactic: apply csInf_le chromaticNumber_bddBelow
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
n : ℕ
hc : Colorable G n
⊢ sInf {n | Colorable G n} ≤ n

tactic: constructor
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
n : ℕ
hc : Colorable G n
⊢ n ∈ {n | Colorable G n}

tactic: exact Classical.choice hc
state_before: case val
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
n : ℕ
hc : Colorable G n
⊢ Coloring G (Fin n)
Theorem: Fin.coe_sub_iff_le
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n✝ m n : ℕ
a b : Fin n
⊢ ↑(a - b) = ↑a - ↑b ↔ b ≤ a

tactic: rw [le_iff_val_le_val, Fin.coe_sub, ← add_tsub_assoc_of_le b.is_lt.le a]
state_before: case succ
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
⊢ ↑(a - b) = ↑a - ↑b ↔ b ≤ a

tactic: cases' le_or_lt (b : ℕ) a with h h
state_before: case succ
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
⊢ (↑a + Nat.succ n✝ - ↑b) % Nat.succ n✝ = ↑a - ↑b ↔ ↑b ≤ ↑a

tactic: exact @finZeroElim (fun _ => _) a
state_before: case zero
n m : ℕ
a b : Fin zero
⊢ ↑(a - b) = ↑a - ↑b ↔ b ≤ a

tactic: simp [← tsub_add_eq_add_tsub h, val_fin_le.mp h,
  Nat.mod_eq_of_lt ((Nat.sub_le _ _).trans_lt a.is_lt)]
state_before: case succ.inl
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
h : ↑b ≤ ↑a
⊢ (↑a + Nat.succ n✝ - ↑b) % Nat.succ n✝ = ↑a - ↑b ↔ ↑b ≤ ↑a

tactic: rw [Nat.mod_eq_of_lt, tsub_eq_zero_of_le h.le, tsub_eq_zero_iff_le, ← not_iff_not]
state_before: case succ.inr
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
h : ↑a < ↑b
⊢ (↑a + Nat.succ n✝ - ↑b) % Nat.succ n✝ = ↑a - ↑b ↔ ↑b ≤ ↑a

tactic: simpa [b.is_lt.trans_le le_add_self] using h
state_before: case succ.inr
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
h : ↑a < ↑b
⊢ ¬↑a + Nat.succ n✝ ≤ ↑b ↔ ¬↑b ≤ ↑a

tactic: rwa [tsub_lt_iff_left (b.is_lt.le.trans le_add_self), add_lt_add_iff_right]
state_before: case succ.inr
n m n✝ : ℕ
a b : Fin (Nat.succ n✝)
h : ↑a < ↑b
⊢ ↑a + Nat.succ n✝ - ↑b < Nat.succ n✝
Theorem: IsLocalization.bot_lt_comap_prime
File: Mathlib/RingTheory/Localization/Ideal.lean

tactic: haveI : IsDomain S := isDomain_of_le_nonZeroDivisors _ hM
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : IsLocalization M S
inst✝ : IsDomain R
hM : M ≤ R⁰
p : Ideal S
hpp : Ideal.IsPrime p
hp0 : p ≠ ⊥
⊢ ⊥ < Ideal.comap (algebraMap R S) p

tactic: rw [← Ideal.comap_bot_of_injective (algebraMap R S) (IsLocalization.injective _ hM)]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : IsLocalization M S
inst✝ : IsDomain R
hM : M ≤ R⁰
p : Ideal S
hpp : Ideal.IsPrime p
hp0 : p ≠ ⊥
this : IsDomain S
⊢ ⊥ < Ideal.comap (algebraMap R S) p

tactic: convert (orderIsoOfPrime M S).lt_iff_lt.mpr (show (⟨⊥, Ideal.bot_prime⟩ :
  { p : Ideal S // p.IsPrime }) < ⟨p, hpp⟩ from hp0.bot_lt)
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : IsLocalization M S
inst✝ : IsDomain R
hM : M ≤ R⁰
p : Ideal S
hpp : Ideal.IsPrime p
hp0 : p ≠ ⊥
this : IsDomain S
⊢ Ideal.comap (algebraMap R S) ⊥ < Ideal.comap (algebraMap R S) p
Theorem: MeasureTheory.L2.norm_sq_eq_inner'
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: have h_two : (2 : ℝ≥0∞).toReal = 2 := by simp
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
⊢ ‖f‖ ^ 2 = ↑IsROrC.re (inner f f)

tactic: rw [inner_def, integral_inner_eq_sq_snorm, norm_def, ← ENNReal.toReal_pow, IsROrC.ofReal_re,
  ENNReal.toReal_eq_toReal (ENNReal.pow_ne_top (Lp.snorm_ne_top f)) _]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ ‖f‖ ^ 2 = ↑IsROrC.re (inner f f)

tactic: simp
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
⊢ ENNReal.toReal 2 = 2

tactic: rw [← ENNReal.rpow_nat_cast, snorm_eq_snorm' two_ne_zero ENNReal.two_ne_top, snorm', ←
  ENNReal.rpow_mul, one_div, h_two]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ snorm (↑↑f) 2 μ ^ 2 = ∫⁻ (a : α), ↑‖↑↑f a‖₊ ^ 2 ∂μ

tactic: simp
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ (∫⁻ (a : α), ↑‖↑↑f a‖₊ ^ 2 ∂μ) ^ (2⁻¹ * ↑2) = ∫⁻ (a : α), ↑‖↑↑f a‖₊ ^ 2 ∂μ

tactic: refine' (lintegral_rpow_nnnorm_lt_top_of_snorm'_lt_top zero_lt_two _).ne
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ (∫⁻ (a : α), ↑‖↑↑f a‖₊ ^ 2 ∂μ) ≠ ⊤

tactic: rw [← h_two, ← snorm_eq_snorm' two_ne_zero ENNReal.two_ne_top]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ snorm' (fun a => ↑↑f a) 2 μ < ⊤

tactic: exact Lp.snorm_lt_top f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.54916
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp E 2 }
h_two : ENNReal.toReal 2 = 2
⊢ snorm (fun a => ↑↑f a) 2 μ < ⊤
Theorem: Turing.TM2to1.supports_run
File: Mathlib/Computability/TuringMachine.lean

tactic: cases s <;> rfl
state_before: K : Type u_2
inst✝² : DecidableEq K
Γ : K → Type u_3
Λ : Type u_1
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
S : Finset Λ
k : K
s : StAct k
q : Stmt₂
⊢ TM2.SupportsStmt S (stRun s q) ↔ TM2.SupportsStmt S q
Theorem: div_le_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_le_iff_le_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ c ↔ a ≤ b * c
Theorem: pow_mem_closedBall
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [mem_closedBall, dist_eq_norm_div, ← div_pow] at h⊢
state_before: 𝓕 : Type ?u.832658
𝕜 : Type ?u.832661
α : Type ?u.832664
ι : Type ?u.832667
κ : Type ?u.832670
E : Type u_1
F : Type ?u.832676
G : Type ?u.832679
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : a ∈ closedBall b r
⊢ a ^ n ∈ closedBall (b ^ n) (n • r)

tactic: refine' (norm_pow_le_mul_norm n (a / b)).trans _
state_before: 𝓕 : Type ?u.832658
𝕜 : Type ?u.832661
α : Type ?u.832664
ι : Type ?u.832667
κ : Type ?u.832670
E : Type u_1
F : Type ?u.832676
G : Type ?u.832679
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ ≤ r
⊢ ‖(a / b) ^ n‖ ≤ n • r

tactic: simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
state_before: 𝓕 : Type ?u.832658
𝕜 : Type ?u.832661
α : Type ?u.832664
ι : Type ?u.832667
κ : Type ?u.832670
E : Type u_1
F : Type ?u.832676
G : Type ?u.832679
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ ≤ r
⊢ ↑n * ‖a / b‖ ≤ n • r
Theorem: Embedding.discreteTopology
File: Mathlib/Topology/Maps.lean

tactic: rw [hf.nhds_eq_comap, nhds_discrete, comap_pure, ← image_singleton, hf.inj.preimage_image,
  principal_singleton]
state_before: α : Type ?u.127326
β : Type ?u.127329
γ : Type ?u.127332
δ : Type ?u.127335
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
tY : TopologicalSpace Y
inst✝ : DiscreteTopology Y
f : X → Y
hf : _root_.Embedding f
x : X
⊢ 𝓝 x = pure x
Theorem: Mathlib.Meta.NormNum.IsNat.to_isRat
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ 1 * ↑1 = 1

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑1 * 1 = 1

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑n✝ = ↑(Int.ofNat n✝) * ⅟↑1
Theorem: Real.tan_nonpos_of_nonpos_of_neg_pi_div_two_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: linarith
state_before: x : ℝ
hx0 : x ≤ 0
hpx : -(π / 2) ≤ x
⊢ 0 ≤ -x

tactic: linarith
state_before: x : ℝ
hx0 : x ≤ 0
hpx : -(π / 2) ≤ x
⊢ -x ≤ π / 2
Theorem: Nat.count_le_cardinal
File: Mathlib/Data/Nat/Count.lean

tactic: rw [count_eq_card_fintype, ← Cardinal.mk_fintype]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ ↑(count p n) ≤ Cardinal.mk ↑{k | p k}

tactic: exact Cardinal.mk_subtype_mono fun x hx ↦ hx.2
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ Cardinal.mk { k // k < n ∧ p k } ≤ Cardinal.mk ↑{k | p k}
Theorem: Pmf.mem_support_pure_iff
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.3232
γ : Type ?u.3235
a a' : α
⊢ a' ∈ support (pure a) ↔ a' = a
Theorem: Complex.tan_add_mul_I
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [tan_add h, tan_mul_I, mul_assoc]
state_before: x y : ℂ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * ↑π / 2) ∧ ∀ (l : ℤ), y * I ≠ (2 * ↑l + 1) * ↑π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * ↑π / 2) ∧ ∃ l, y * I = (2 * ↑l + 1) * ↑π / 2
⊢ tan (x + y * I) = (tan x + tanh y * I) / (1 - tan x * tanh y * I)
Theorem: Finpartition.card_bind
File: Mathlib/Order/Partition/Finpartition.lean

tactic: apply card_biUnion
state_before: α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ card (bind P Q).parts = ∑ A in attach P.parts, card (Q ↑A (_ : ↑A ∈ P.parts)).parts

tactic: rintro ⟨b, hb⟩ - ⟨c, hc⟩ - hbc
state_before: case h
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ ∀ (x : { x // x ∈ P.parts }),
    x ∈ attach P.parts →
      ∀ (y : { x // x ∈ P.parts }),
        y ∈ attach P.parts →
          x ≠ y → Disjoint ((fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) x) ((fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) y)

tactic: rw [Finset.disjoint_left]
state_before: case h.mk.mk
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b✝ c✝ : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
b : α
hb : b ∈ P.parts
c : α
hc : c ∈ P.parts
hbc : { val := b, property := hb } ≠ { val := c, property := hc }
⊢ Disjoint ((fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := b, property := hb })
    ((fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := c, property := hc })

tactic: rintro d hdb hdc
state_before: case h.mk.mk
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b✝ c✝ : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
b : α
hb : b ∈ P.parts
c : α
hc : c ∈ P.parts
hbc : { val := b, property := hb } ≠ { val := c, property := hc }
⊢ ∀ ⦃a_1 : α⦄,
    a_1 ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := b, property := hb } →
      ¬a_1 ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := c, property := hc }

tactic: rw [Ne.def, Subtype.mk_eq_mk] at hbc
state_before: case h.mk.mk
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b✝ c✝ : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
b : α
hb : b ∈ P.parts
c : α
hc : c ∈ P.parts
hbc : { val := b, property := hb } ≠ { val := c, property := hc }
d : α
hdb : d ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := b, property := hb }
hdc : d ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := c, property := hc }
⊢ False

tactic: exact
  (Q b hb).ne_bot hdb
    (eq_bot_iff.2 <|
      (le_inf ((Q b hb).le hdb) <| (Q c hc).le hdc).trans <| (P.disjoint hb hc hbc).le_bot)
state_before: case h.mk.mk
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b✝ c✝ : α
P : Finpartition a
Q✝ Q : (i : α) → i ∈ P.parts → Finpartition i
b : α
hb : b ∈ P.parts
c : α
hc : c ∈ P.parts
hbc : ¬b = c
d : α
hdb : d ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := b, property := hb }
hdc : d ∈ (fun i => (Q ↑i (_ : ↑i ∈ P.parts)).parts) { val := c, property := hc }
⊢ False
Theorem: Polynomial.Chebyshev.aeval_T
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

tactic: rw [aeval_def, eval₂_eq_eval_map, map_T]
state_before: R : Type u_2
A : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
x : A
n : ℕ
⊢ ↑(aeval x) (T R n) = eval x (T A n)
Theorem: MvPolynomial.degrees_map_of_injective
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: simp only [degrees, MvPolynomial.support_map_of_injective _ hf]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.78666
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
hf : Injective ↑f
⊢ degrees (↑(map f) p) = degrees p
Theorem: LinearMap.compMultilinearMap_alternatization
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_4
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type ?u.744012
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type ?u.744042
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type ?u.744072
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_2
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_5
ι' : Type ?u.744851
ι'' : Type ?u.744854
N'₂ : Type u_3
inst✝³ : AddCommGroup N'₂
inst✝² : Module R N'₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
g : N' →ₗ[R] N'₂
f : MultilinearMap R (fun x => M) N'
⊢ ↑MultilinearMap.alternatization (compMultilinearMap g f) = ↑(compAlternatingMap g) (↑MultilinearMap.alternatization f)

tactic: simp [MultilinearMap.alternatization_def]
state_before: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_4
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type ?u.744012
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type ?u.744042
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type ?u.744072
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_2
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_5
ι' : Type ?u.744851
ι'' : Type ?u.744854
N'₂ : Type u_3
inst✝³ : AddCommGroup N'₂
inst✝² : Module R N'₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
g : N' →ₗ[R] N'₂
f : MultilinearMap R (fun x => M) N'
x✝ : ι → M
⊢ ↑(↑MultilinearMap.alternatization (compMultilinearMap g f)) x✝ =
    ↑(↑(compAlternatingMap g) (↑MultilinearMap.alternatization f)) x✝
Theorem: Int.sub_sub
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.sub_eq_add_neg, Int.add_assoc]
state_before: a b c : Int
⊢ a - b - c = a - (b + c)
Theorem: List.mem_keys_kinsert
File: Mathlib/Data/List/Sigma.lean

tactic: by_cases h : a = a' <;> simp [h]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
⊢ a ∈ keys (kinsert a' b' l) ↔ a = a' ∨ a ∈ keys l
Theorem: List.indexOf_append_of_not_mem
File: Mathlib/Data/List/Basic.lean

tactic: induction' l₁ with d₁ t₁ ih
state_before: ι : Type ?u.82162
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : ¬a ∈ l₁
⊢ indexOf a (l₁ ++ l₂) = length l₁ + indexOf a l₂

tactic: rw [List.cons_append, indexOf_cons_ne _ (ne_of_not_mem_cons h), List.length,
  ih (not_mem_of_not_mem_cons h), Nat.succ_add]
state_before: case cons
ι : Type ?u.82162
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : ¬a ∈ l₁
d₁ : α
t₁ : List α
ih : ¬a ∈ t₁ → indexOf a (t₁ ++ l₂) = length t₁ + indexOf a l₂
h : ¬a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = length (d₁ :: t₁) + indexOf a l₂

tactic: rw [List.nil_append, List.length, zero_add]
state_before: case nil
ι : Type ?u.82162
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : ¬a ∈ l₁
h : ¬a ∈ []
⊢ indexOf a ([] ++ l₂) = length [] + indexOf a l₂
Theorem: sub_pow_char_pow_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

tactic: induction n with
| zero => simp
| succ n n_ih =>
    rw [pow_succ', pow_mul, pow_mul, pow_mul, n_ih]
    apply sub_pow_char_of_commute; apply Commute.pow_pow h
state_before: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
n : ℕ
x y : R
h : Commute x y
⊢ (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n

tactic: simp
state_before: case zero
R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y) ^ p ^ Nat.zero = x ^ p ^ Nat.zero - y ^ p ^ Nat.zero

tactic: rw [pow_succ', pow_mul, pow_mul, pow_mul, n_ih]
state_before: case succ
R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
n : ℕ
n_ih : (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n
⊢ (x - y) ^ p ^ Nat.succ n = x ^ p ^ Nat.succ n - y ^ p ^ Nat.succ n

tactic: apply sub_pow_char_of_commute
state_before: case succ
R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
n : ℕ
n_ih : (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n
⊢ (x ^ p ^ n - y ^ p ^ n) ^ p = (x ^ p ^ n) ^ p - (y ^ p ^ n) ^ p

tactic: apply Commute.pow_pow h
state_before: case succ.h
R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
n : ℕ
n_ih : (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n
⊢ Commute (x ^ p ^ n) (y ^ p ^ n)
Theorem: Finsupp.equivFunOnFinite_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.138459
γ : Type ?u.138462
ι : Type ?u.138465
M : Type u_2
M' : Type ?u.138471
N : Type ?u.138474
P : Type ?u.138477
G : Type ?u.138480
H : Type ?u.138483
R : Type ?u.138486
S : Type ?u.138489
inst✝² : Zero M
a a' : α
b : M
inst✝¹ : DecidableEq α
inst✝ : Finite α
x : α
m : M
⊢ ↑equivFunOnFinite (single x m) = Pi.single x m

tactic: simp [Finsupp.single_eq_pi_single, equivFunOnFinite]
state_before: case h
α : Type u_1
β : Type ?u.138459
γ : Type ?u.138462
ι : Type ?u.138465
M : Type u_2
M' : Type ?u.138471
N : Type ?u.138474
P : Type ?u.138477
G : Type ?u.138480
H : Type ?u.138483
R : Type ?u.138486
S : Type ?u.138489
inst✝² : Zero M
a a' : α
b : M
inst✝¹ : DecidableEq α
inst✝ : Finite α
x : α
m : M
x✝ : α
⊢ ↑equivFunOnFinite (single x m) x✝ = Pi.single x m x✝