tasksource/leandojo huggingface dataset:
Theorem: LieSubmodule.mem_lieSpan
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: change x ∈ (lieSpan R L s : Set M) ↔ _
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 N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ lieSpan R L s ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N

tactic: erw [sInf_coe]
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 N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ ↑(lieSpan R L s) ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N

tactic: exact mem_iInter₂
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 N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ (x ∈ ⋂ (s_1 : LieSubmodule R L M) (_ : s_1 ∈ {N | s ⊆ ↑N}), ↑s_1) ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
Theorem: Polynomial.coeff_eq_esymm_roots_of_card
File: Mathlib/RingTheory/Polynomial/Vieta.lean

tactic: conv_lhs => rw [← C_leadingCoeff_mul_prod_multiset_X_sub_C hroots]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ coeff p k = leadingCoeff p * (-1) ^ (natDegree p - k) * esymm (roots p) (natDegree p - k)

tactic: rw [coeff_C_mul, mul_assoc]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ coeff (↑C (leadingCoeff p) * prod (map (fun a => X - ↑C a) (roots p))) k =
    leadingCoeff p * (-1) ^ (natDegree p - k) * esymm (roots p) (natDegree p - k)

tactic: congr
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ leadingCoeff p * coeff (prod (map (fun a => X - ↑C a) (roots p))) k =
    leadingCoeff p * ((-1) ^ (natDegree p - k) * esymm (roots p) (natDegree p - k))

tactic: have : k ≤ card (roots p) := by rw [hroots]; exact h
state_before: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ coeff (prod (map (fun a => X - ↑C a) (roots p))) k = (-1) ^ (natDegree p - k) * esymm (roots p) (natDegree p - k)

tactic: convert p.roots.prod_X_sub_C_coeff this using 3 <;> rw [hroots]
state_before: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
this : k ≤ ↑card (roots p)
⊢ coeff (prod (map (fun a => X - ↑C a) (roots p))) k = (-1) ^ (natDegree p - k) * esymm (roots p) (natDegree p - k)

tactic: rw [hroots]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ k ≤ ↑card (roots p)

tactic: exact h
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : ↑card (roots p) = natDegree p
k : ℕ
h : k ≤ natDegree p
⊢ k ≤ natDegree p
Theorem: Function.iterate_add_minimalPeriod_eq
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [iterate_add_apply]
state_before: α : Type u_1
β : Type ?u.19831
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ (f^[n + minimalPeriod f x]) x = (f^[n]) x

tactic: congr
state_before: α : Type u_1
β : Type ?u.19831
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ (f^[n]) ((f^[minimalPeriod f x]) x) = (f^[n]) x

tactic: exact isPeriodicPt_minimalPeriod f x
state_before: case e_a
α : Type u_1
β : Type ?u.19831
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ (f^[minimalPeriod f x]) x = x
Theorem: CategoryTheory.Limits.cospanExt_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).app WalkingCospan.right = iY
Theorem: Real.Angle.cos_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ cos (θ + ↑(π / 2)) = -sin θ

tactic: exact Real.cos_add_pi_div_two _
state_before: case h
x✝ : ℝ
⊢ cos (↑x✝ + ↑(π / 2)) = -sin ↑x✝
Theorem: Ordinal.lift_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← add_one_eq_succ, lift_add, lift_one]
state_before: α : Type ?u.839
β : Type ?u.842
γ : Type ?u.845
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ lift (succ a) = succ (lift a)

tactic: rfl
state_before: α : Type ?u.839
β : Type ?u.842
γ : Type ?u.845
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ lift a + 1 = succ (lift a)
Theorem: Nat.sq_add_sq_modEq
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: simpa only [← Int.coe_nat_modEq_iff] using Nat.sq_add_sq_zmodEq p x
state_before: K : Type ?u.856220
R : Type ?u.856223
p : ℕ
inst✝ : Fact (Prime p)
x : ℕ
⊢ ∃ a b, a ≤ p / 2 ∧ b ≤ p / 2 ∧ a ^ 2 + b ^ 2 ≡ x [MOD p]
Theorem: Option.bind_pmap
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [pmap, bind_eq_bind, none_bind, some_bind, pbind]
state_before: α✝ : Type ?u.10527
β✝ : Type ?u.10530
γ✝ : Type ?u.10533
δ : Type ?u.10536
p✝ : α✝ → Prop
f✝ : (a : α✝) → p✝ a → β✝
x✝ : Option α✝
α : Type u_1
β γ : Type u_2
p : α → Prop
f : (a : α) → p a → β
x : Option α
g : β → Option γ
H : ∀ (a : α), a ∈ x → p a
⊢ pmap f x H >>= g = pbind x fun a h => g (f a (_ : p a))
Theorem: contDiffOn_succ_of_fderivWithin
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: intro x hx
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hf : DifferentiableOn 𝕜 f s
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s
⊢ ContDiffOn 𝕜 (↑(n + 1)) f s

tactic: rw [contDiffWithinAt_succ_iff_hasFDerivWithinAt, insert_eq_of_mem hx]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hf : DifferentiableOn 𝕜 f s
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s
x : E
hx : x ∈ s
⊢ ContDiffWithinAt 𝕜 (↑(n + 1)) f s x

tactic: exact
  ⟨s, self_mem_nhdsWithin, fderivWithin 𝕜 f s, fun y hy => (hf y hy).hasFDerivWithinAt, h x hx⟩
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hf : DifferentiableOn 𝕜 f s
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s
x : E
hx : x ∈ s
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : E), x ∈ u → HasFDerivWithinAt f (f' x) u x) ∧ ContDiffWithinAt 𝕜 (↑n) f' u x
Theorem: BilinForm.neg_left
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [← @neg_one_smul R₁ _ _, smul_left, neg_one_mul]
state_before: R : Type ?u.48014
M : Type ?u.48017
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.48665
M₂ : Type ?u.48668
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.48855
M₃ : Type ?u.48858
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.49446
K : Type ?u.49449
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
x y : M₁
⊢ bilin B₁ (-x) y = -bilin B₁ x y
Theorem: Equiv.swap_apply_ne_self_iff
File: Mathlib/Logic/Equiv/Basic.lean

tactic: by_cases hab : a = b
state_before: α : Sort u_1
inst✝ : DecidableEq α
a b x : α
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: by_cases hax : x = a
state_before: case neg
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : ¬a = b
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: by_cases hbx : x = b
state_before: case neg
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : ¬a = b
hax : ¬x = a
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: simp [hab, hax, hbx, swap_apply_of_ne_of_ne]
state_before: case neg
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : ¬a = b
hax : ¬x = a
hbx : ¬x = b
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: simp [hab]
state_before: case pos
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : a = b
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: simp [hax, eq_comm]
state_before: case pos
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : ¬a = b
hax : x = a
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)

tactic: simp [hbx]
state_before: case pos
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
hab : ¬a = b
hax : ¬x = a
hbx : x = b
⊢ ↑(swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)
Theorem: IsOfFinOrder.of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp h'
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
h : IsOfFinOrder x
h' : y ∈ Subgroup.zpowers x
⊢ IsOfFinOrder y

tactic: exact h.zpow
state_before: case intro
G : Type u
A : Type v
x : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
h : IsOfFinOrder x
k : ℤ
h' : x ^ k ∈ Subgroup.zpowers x
⊢ IsOfFinOrder (x ^ k)
Theorem: Set.prod_eq_biUnion_left
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [iUnion_image_left, image2_mk_eq_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.257641
ι : Sort ?u.257644
ι' : Sort ?u.257647
ι₂ : Sort ?u.257650
κ : ι → Sort ?u.257655
κ₁ : ι → Sort ?u.257660
κ₂ : ι → Sort ?u.257665
κ' : ι' → Sort ?u.257670
f : α → β → γ
s : Set α
t : Set β
⊢ s ×ˢ t = ⋃ (a : α) (_ : a ∈ s), (fun b => (a, b)) '' t
Theorem: Submodule.ker_ofLe
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [ofLe, ker_codRestrict, ker_subtype]
state_before: R : Type u_1
R₁ : Type ?u.1544682
R₂ : Type ?u.1544685
R₃ : Type ?u.1544688
R₄ : Type ?u.1544691
S : Type ?u.1544694
K : Type ?u.1544697
K₂ : Type ?u.1544700
M : Type u_2
M' : Type ?u.1544706
M₁ : Type ?u.1544709
M₂ : Type ?u.1544712
M₃ : Type ?u.1544715
M₄ : Type ?u.1544718
N : Type ?u.1544721
N₂ : Type ?u.1544724
ι : Type ?u.1544727
V : Type ?u.1544730
V₂ : Type ?u.1544733
inst✝⁵ : Semiring R
inst✝⁴ : Semiring R₂
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type ?u.1544907
sc : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
h : p ≤ p'
⊢ ker (ofLe h) = ⊥
Theorem: isLowerSet_iff_Iio_subset
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [isLowerSet_iff_forall_lt, subset_def, @forall_swap (_ ∈ s)]
state_before: α : Type u_1
β : Type ?u.34448
γ : Type ?u.34451
ι : Sort ?u.34454
κ : ι → Sort ?u.34459
inst✝ : PartialOrder α
s : Set α
⊢ IsLowerSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Iio a ⊆ s
Theorem: continuousWithinAt_Ioc_iff_Iic
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Ioc_eq_nhdsWithin_Iic h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
a✝ b✝ : α
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace β
a b : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Ioc a b) b ↔ ContinuousWithinAt f (Iic b) b
Theorem: Equiv.Perm.exists_fixed_point_of_prime'
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: classical
  have h : ∀ b : α, b ∈ σ.supportᶜ ↔ σ b = b := fun b => by
    rw [Finset.mem_compl, mem_support, Classical.not_not]
  obtain ⟨b, hb1, hb2⟩ := Finset.exists_ne_of_one_lt_card (hp.out.one_lt.trans_le
    (Nat.le_of_dvd (Finset.card_pos.mpr ⟨a, (h a).mpr ha⟩) (Nat.modEq_zero_iff_dvd.mp
      ((card_compl_support_modEq hσ).trans (Nat.modEq_zero_iff_dvd.mpr hα))))) a
  exact ⟨b, (h b).mp hb1, hb2⟩
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : ↑σ a = a
⊢ ∃ b, ↑σ b = b ∧ b ≠ a

tactic: have h : ∀ b : α, b ∈ σ.supportᶜ ↔ σ b = b := fun b => by
  rw [Finset.mem_compl, mem_support, Classical.not_not]
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : ↑σ a = a
⊢ ∃ b, ↑σ b = b ∧ b ≠ a

tactic: obtain ⟨b, hb1, hb2⟩ := Finset.exists_ne_of_one_lt_card (hp.out.one_lt.trans_le
  (Nat.le_of_dvd (Finset.card_pos.mpr ⟨a, (h a).mpr ha⟩) (Nat.modEq_zero_iff_dvd.mp
    ((card_compl_support_modEq hσ).trans (Nat.modEq_zero_iff_dvd.mpr hα))))) a
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : ↑σ a = a
h : ∀ (b : α), b ∈ support σᶜ ↔ ↑σ b = b
⊢ ∃ b, ↑σ b = b ∧ b ≠ a

tactic: exact ⟨b, (h b).mp hb1, hb2⟩
state_before: case intro.intro
α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : ↑σ a = a
h : ∀ (b : α), b ∈ support σᶜ ↔ ↑σ b = b
b : α
hb1 : b ∈ support σᶜ
hb2 : b ≠ a
⊢ ∃ b, ↑σ b = b ∧ b ≠ a

tactic: rw [Finset.mem_compl, mem_support, Classical.not_not]
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : ↑σ a = a
b : α
⊢ b ∈ support σᶜ ↔ ↑σ b = b
Theorem: CategoryTheory.μ_naturality₂
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: have := congr_app (F.toLaxMonoidalFunctor.μ_natural f g) X
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X

tactic: dsimp [endofunctorMonoidalCategory] at this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
this :
  ((F.map f ⊗ F.map g) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n ≫ F.map (f ⊗ g)).app X
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X

tactic: simpa using this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
this :
  ((F.map g).app ((F.obj m).obj X) ≫ (F.obj n').map ((F.map f).app X)) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X
Theorem: Ordinal.le_mul_right
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: convert mul_le_mul_right' (one_le_iff_pos.2 hb) a
state_before: α : Type ?u.194451
β : Type ?u.194454
γ : Type ?u.194457
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
hb : 0 < b
⊢ a ≤ b * a

tactic: rw [one_mul a]
state_before: case h.e'_3
α : Type ?u.194451
β : Type ?u.194454
γ : Type ?u.194457
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
hb : 0 < b
⊢ a = 1 * a
Theorem: existsUnique_add_zsmul_mem_Ico
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: simpa only [Equiv.neg_apply, mem_Ico, neg_zsmul, ← sub_eq_add_neg, le_sub_iff_add_le, zero_add,
  add_comm c, sub_lt_iff_lt_add', add_assoc] using existsUnique_zsmul_near_of_pos' ha (b - c)
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
a : α
ha : 0 < a
b c : α
⊢ ∃! x, b + ↑(Equiv.neg ℤ) x • a ∈ Ico c (c + a)
Theorem: Nat.cast_pow
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: induction' m with m ih
state_before: α : Type ?u.266183
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Semiring R
n m : ℕ
⊢ ↑(n ^ m) = ↑n ^ m

tactic: simp
state_before: case zero
α : Type ?u.266183
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Semiring R
n : ℕ
⊢ ↑(n ^ zero) = ↑n ^ zero

tactic: rw [_root_.pow_succ', _root_.pow_succ', Nat.cast_mul, ih]
state_before: case succ
α : Type ?u.266183
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Semiring R
n m : ℕ
ih : ↑(n ^ m) = ↑n ^ m
⊢ ↑(n ^ succ m) = ↑n ^ succ m
Theorem: Cardinal.prod_le_prod
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: have := H i
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal
H : ∀ (i : ι), f i ≤ g i
i : ι
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g i))

tactic: rwa [← mk_out (f i), ← mk_out (g i)] at this
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal
H : ∀ (i : ι), f i ≤ g i
i : ι
this : f i ≤ g i
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g i))
Theorem: IsChain.exists3
File: Mathlib/Order/Chain.lean

tactic: rcases directedOn_iff_directed.mpr (IsChain.directed hchain) a mem1 b mem2 with ⟨z, mem4, H1, H2⟩
state_before: α : Type u_1
β : Type ?u.5666
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝¹ : IsRefl α r
hchain : IsChain r s
inst✝ : IsTrans α r
a b c : α
mem1 : a ∈ s
mem2 : b ∈ s
mem3 : c ∈ s
⊢ ∃ z x, r a z ∧ r b z ∧ r c z

tactic: rcases directedOn_iff_directed.mpr (IsChain.directed hchain) z mem4 c mem3 with
  ⟨z', mem5, H3, H4⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.5666
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝¹ : IsRefl α r
hchain : IsChain r s
inst✝ : IsTrans α r
a b c : α
mem1 : a ∈ s
mem2 : b ∈ s
mem3 : c ∈ s
z : α
mem4 : z ∈ s
H1 : r a z
H2 : r b z
⊢ ∃ z x, r a z ∧ r b z ∧ r c z

tactic: exact ⟨z', mem5, _root_.trans H1 H3, _root_.trans H2 H3, H4⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.5666
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝¹ : IsRefl α r
hchain : IsChain r s
inst✝ : IsTrans α r
a b c : α
mem1 : a ∈ s
mem2 : b ∈ s
mem3 : c ∈ s
z : α
mem4 : z ∈ s
H1 : r a z
H2 : r b z
z' : α
mem5 : z' ∈ s
H3 : r z z'
H4 : r c z'
⊢ ∃ z x, r a z ∧ r b z ∧ r c z
Theorem: Set.ordConnectedComponent_eq_empty
File: Mathlib/Data/Set/Intervals/OrdConnectedComponent.lean

tactic: rw [← not_nonempty_iff_eq_empty, nonempty_ordConnectedComponent]
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x y z : α
⊢ ordConnectedComponent s x = ∅ ↔ ¬x ∈ s
Theorem: Complex.mul_cpow_ofReal_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rcases eq_or_ne r 0 with (rfl | hr)
state_before: a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: rcases eq_or_lt_of_le ha with (rfl | ha')
state_before: case inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: rcases eq_or_lt_of_le hb with (rfl | hb')
state_before: case inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: have ha'' : (a : ℂ) ≠ 0 := ofReal_ne_zero.mpr ha'.ne'
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: have hb'' : (b : ℂ) ≠ 0 := ofReal_ne_zero.mpr hb'.ne'
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: rw [cpow_def_of_ne_zero (mul_ne_zero ha'' hb''), log_ofReal_mul ha' hb'', ofReal_log ha,
  add_mul, exp_add, ← cpow_def_of_ne_zero ha'', ← cpow_def_of_ne_zero hb'']
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
hb'' : ↑b ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

tactic: simp only [cpow_zero, mul_one]
state_before: case inl
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ (↑a * ↑b) ^ 0 = ↑a ^ 0 * ↑b ^ 0

tactic: rw [ofReal_zero, MulZeroClass.zero_mul, zero_cpow hr, MulZeroClass.zero_mul]
state_before: case inr.inl
b : ℝ
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha : 0 ≤ 0
⊢ (↑0 * ↑b) ^ r = ↑0 ^ r * ↑b ^ r

tactic: rw [ofReal_zero, MulZeroClass.mul_zero, zero_cpow hr, MulZeroClass.mul_zero]
state_before: case inr.inr.inl
a : ℝ
ha : 0 ≤ a
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb : 0 ≤ 0
⊢ (↑a * ↑0) ^ r = ↑a ^ r * ↑0 ^ r
Theorem: Zspan.coe_floor_self
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: rw [repr_floor_apply, Basis.singleton_repr, Basis.singleton_repr]
state_before: E : Type ?u.329491
ι : Type u_2
K : Type u_1
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Fintype ι
inst✝ : Unique ι
k : K
x✝ : ?m.331445 k
⊢ ↑(↑(?m.331449 k).repr ↑(floor (Basis.singleton ι K) k)) x✝ = ↑(↑(?m.331449 k).repr ↑⌊k⌋) x✝
Theorem: lt_of_smul_lt_smul_of_nonneg
File: Mathlib/Algebra/Order/SMul.lean

tactic: rwa [← hc, zero_smul, zero_smul] at h
state_before: ι : Type ?u.37321
𝕜 : Type ?u.37324
R : Type u_2
M : Type u_1
N : Type ?u.37333
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a b : M
c : R
h : c • a < c • b
hc✝ : 0 ≤ c
hc : 0 = c
⊢ 0 < 0
Theorem: Module.DualBases.coe_dualBasis
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [h.basis.dualBasis_apply_self, h.coe_basis, h.eval, if_congr eq_comm rfl rfl]
state_before: R : Type u_2
M : Type u_3
ι : Type u_1
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
e : ι → M
ε : ι → Dual R M
inst✝¹ : DecidableEq ι
h : DualBases e ε
inst✝ : Fintype ι
i j : ι
⊢ ↑(↑(Basis.dualBasis (basis h)) i) (↑(basis h) j) = ↑(ε i) (↑(basis h) j)
Theorem: MeasureTheory.withDensityᵥ_zero
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.21804
m : MeasurableSpace α
μ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
⊢ withDensityᵥ μ 0 = 0

tactic: erw [withDensityᵥ_apply (integrable_zero α E μ) hs]
state_before: case h
α : Type u_1
β : Type ?u.21804
m : MeasurableSpace α
μ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ ↑(withDensityᵥ μ 0) s = ↑0 s

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.21804
m : MeasurableSpace α
μ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
s : Set α
hs : MeasurableSet s
⊢ (∫ (x : α) in s, 0 ∂μ) = ↑0 s