tasksource/leandojo huggingface dataset:
Theorem: Finset.subset_union_elim
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [filter_union_right, em]
state_before: case refine'_1
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
⊢ filter (fun x => x ∈ t₁) s ∪ filter (fun x => ¬x ∈ t₁) s = s

tactic: intro x
state_before: case refine'_2
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
⊢ ↑(filter (fun x => x ∈ t₁) s) ⊆ t₁

tactic: simp
state_before: case refine'_2
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
⊢ x ∈ ↑(filter (fun x => x ∈ t₁) s) → x ∈ t₁

tactic: intro x
state_before: case refine'_3
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
⊢ ↑(filter (fun x => ¬x ∈ t₁) s) ⊆ t₂ \ t₁

tactic: simp
state_before: case refine'_3
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
⊢ x ∈ ↑(filter (fun x => ¬x ∈ t₁) s) → x ∈ t₂ \ t₁

tactic: intro hx hx₂
state_before: case refine'_3
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
⊢ x ∈ s → ¬x ∈ t₁ → x ∈ t₂ ∧ ¬x ∈ t₁

tactic: refine' ⟨Or.resolve_left (h hx) hx₂, hx₂⟩
state_before: case refine'_3
α : Type u_1
β : Type ?u.400981
γ : Type ?u.400984
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
hx : x ∈ s
hx₂ : ¬x ∈ t₁
⊢ x ∈ t₂ ∧ ¬x ∈ t₁
Theorem: Int.toNat_lt
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.not_le, ← Nat.not_le, Int.le_toNat h]
state_before: n : Nat
z : Int
h : 0 ≤ z
⊢ toNat z < n ↔ z < ↑n
Theorem: IsPrimitiveRoot.zmodEquivZpowers_symm_apply_pow
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [← h.zmodEquivZpowers.symm_apply_apply i, zmodEquivZpowers_apply_coe_nat]
state_before: M : Type ?u.3141531
N : Type ?u.3141534
G : Type ?u.3141537
R : Type u_1
S : Type ?u.3141543
F : Type ?u.3141546
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
⊢ ↑(AddEquiv.symm (zmodEquivZpowers h))
      (↑Additive.ofMul { val := ζ ^ i, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) ζ y = ζ ^ i) }) =
    ↑i
Theorem: innerSL_apply_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: refine'
  le_antisymm ((innerSL 𝕜 x).op_norm_le_bound (norm_nonneg _) fun y => norm_inner_le_norm _ _) _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ‖↑(innerSL 𝕜) x‖ = ‖x‖

tactic: rcases eq_or_ne x 0 with (rfl | h)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ‖x‖ ≤ ‖↑(innerSL 𝕜) x‖

tactic: simp
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
⊢ ‖0‖ ≤ ‖↑(innerSL 𝕜) 0‖

tactic: refine' (mul_le_mul_right (norm_pos_iff.2 h)).mp _
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
h : x ≠ 0
⊢ ‖x‖ ≤ ‖↑(innerSL 𝕜) x‖

tactic: calc
  ‖x‖ * ‖x‖ = ‖(⟪x, x⟫ : 𝕜)‖ := by
    rw [← sq, inner_self_eq_norm_sq_to_K, norm_pow, norm_ofReal, abs_norm]
  _ ≤ ‖innerSL 𝕜 x‖ * ‖x‖ := (innerSL 𝕜 x).le_op_norm _
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
h : x ≠ 0
⊢ ‖x‖ * ‖x‖ ≤ ‖↑(innerSL 𝕜) x‖ * ‖x‖

tactic: rw [← sq, inner_self_eq_norm_sq_to_K, norm_pow, norm_ofReal, abs_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3288929
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
h : x ≠ 0
⊢ ‖x‖ * ‖x‖ = ‖inner x x‖
Theorem: Set.zero_mem_smul_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: constructor
state_before: F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
⊢ 0 ∈ s • t ↔ 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s

tactic: rintro ⟨a, b, ha, hb, h⟩
state_before: case mp
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
⊢ 0 ∈ s • t → 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s

tactic: obtain rfl | rfl := eq_zero_or_eq_zero_of_smul_eq_zero h
state_before: case mp.intro.intro.intro.intro
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a✝ a : α
b : β
ha : a ∈ s
hb : b ∈ t
h : (fun x x_1 => x • x_1) a b = 0
⊢ 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s

tactic: exact Or.inl ⟨ha, b, hb⟩
state_before: case mp.intro.intro.intro.intro.inl
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
b : β
hb : b ∈ t
ha : 0 ∈ s
h : (fun x x_1 => x • x_1) 0 b = 0
⊢ 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s

tactic: exact Or.inr ⟨hb, a, ha⟩
state_before: case mp.intro.intro.intro.intro.inr
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a✝ a : α
ha : a ∈ s
hb : 0 ∈ t
h : (fun x x_1 => x • x_1) a 0 = 0
⊢ 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s

tactic: rintro (⟨hs, b, hb⟩ | ⟨ht, a, ha⟩)
state_before: case mpr
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
⊢ 0 ∈ s ∧ Set.Nonempty t ∨ 0 ∈ t ∧ Set.Nonempty s → 0 ∈ s • t

tactic: exact ⟨0, b, hs, hb, zero_smul _ _⟩
state_before: case mpr.inl.intro.intro
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
hs : 0 ∈ s
b : β
hb : b ∈ t
⊢ 0 ∈ s • t

tactic: exact ⟨a, 0, ha, ht, smul_zero _⟩
state_before: case mpr.inr.intro.intro
F : Type ?u.93331
α : Type u_2
β : Type u_1
γ : Type ?u.93340
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a✝ : α
ht : 0 ∈ t
a : α
ha : a ∈ s
⊢ 0 ∈ s • t
Theorem: map_seq
File: Mathlib/Control/Basic.lean

tactic: simp only [← pure_seq]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
f : β → γ
x : F (α → β)
y : F α
⊢ (f <$> Seq.seq x fun x => y) = Seq.seq ((fun x => f ∘ x) <$> x) fun x => y

tactic: simp [seq_assoc]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
f : β → γ
x : F (α → β)
y : F α
⊢ (Seq.seq (pure f) fun x_1 => Seq.seq x fun x => y) = Seq.seq (Seq.seq (pure fun x => f ∘ x) fun x_1 => x) fun x => y
Theorem: Submodule.not_mem_of_ortho
File: Mathlib/Algebra/Module/Submodule/Basic.lean

tactic: intro hx
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R) (y : M), y ∈ N → c • x + y = 0 → c = 0
⊢ ¬x ∈ N

tactic: simpa using ortho (-1) x hx
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R) (y : M), y ∈ N → c • x + y = 0 → c = 0
hx : x ∈ N
⊢ False
Theorem: LieIdeal.ker_incl
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: ext
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ LieHom.ker (incl I) = ⊥

tactic: simp
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : { x // x ∈ ↑I }
⊢ m✝ ∈ LieHom.ker (incl I) ↔ m✝ ∈ ⊥
Theorem: Matrix.twoBlockTriangular_det'
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rw [M.twoBlockTriangular_det fun i => ¬p i, mul_comm]
state_before: α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ det M = det (toSquareBlockProp M p) * det (toSquareBlockProp M fun i => ¬p i)

tactic: congr 1
state_before: α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ det (toSquareBlockProp M fun i => ¬¬p i) * det (toSquareBlockProp M fun i => ¬p i) =
    det (toSquareBlockProp M p) * det (toSquareBlockProp M fun i => ¬p i)

α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ ∀ (i : m), ¬¬p i → ∀ (j : m), ¬p j → M i j = 0

tactic: exact equiv_block_det _ fun _ => not_not.symm
state_before: case e_a
α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ det (toSquareBlockProp M fun i => ¬¬p i) = det (toSquareBlockProp M p)

α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ ∀ (i : m), ¬¬p i → ∀ (j : m), ¬p j → M i j = 0

tactic: simpa only [Classical.not_not] using h
state_before: α : Type ?u.96201
β : Type ?u.96204
m : Type u_1
n : Type ?u.96210
o : Type ?u.96213
m' : α → Type ?u.96218
n' : α → Type ?u.96223
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0
⊢ ∀ (i : m), ¬¬p i → ∀ (j : m), ¬p j → M i j = 0
Theorem: Fermat42.mul
File: Mathlib/NumberTheory/Fermat4.lean

tactic: delta Fermat42
state_before: a b c k : ℤ
hk0 : k ≠ 0
⊢ Fermat42 a b c ↔ Fermat42 (k * a) (k * b) (k ^ 2 * c)

tactic: constructor
state_before: a b c k : ℤ
hk0 : k ≠ 0
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: intro f42
state_before: case mp
a b c k : ℤ
hk0 : k ≠ 0
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 → k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: constructor
state_before: case mp
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
⊢ k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: constructor
state_before: case mp.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
⊢ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: exact mul_ne_zero hk0 f42.1
state_before: case mp.left
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
⊢ k * a ≠ 0

tactic: exact mul_ne_zero hk0 f42.2.1
state_before: case mp.right.left
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
⊢ k * b ≠ 0

tactic: have H : a ^ 4 + b ^ 4 = c ^ 2 := f42.2.2
state_before: case mp.right.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
⊢ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: linear_combination k ^ 4 * H
state_before: case mp.right.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2
H : a ^ 4 + b ^ 4 = c ^ 2
⊢ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2

tactic: intro f42
state_before: case mpr
a b c k : ℤ
hk0 : k ≠ 0
⊢ k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2 → a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2

tactic: constructor
state_before: case mpr
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2

tactic: constructor
state_before: case mpr.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2

tactic: apply (mul_right_inj' (pow_ne_zero 4 hk0)).mp
state_before: case mpr.right.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ a ^ 4 + b ^ 4 = c ^ 2

tactic: linear_combination f42.2.2
state_before: case mpr.right.right
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ k ^ 4 * (a ^ 4 + b ^ 4) = k ^ 4 * c ^ 2

tactic: exact right_ne_zero_of_mul f42.1
state_before: case mpr.left
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ a ≠ 0

tactic: exact right_ne_zero_of_mul f42.2.1
state_before: case mpr.right.left
a b c k : ℤ
hk0 : k ≠ 0
f42 : k * a ≠ 0 ∧ k * b ≠ 0 ∧ (k * a) ^ 4 + (k * b) ^ 4 = (k ^ 2 * c) ^ 2
⊢ b ≠ 0
Theorem: Fin.val_add_eq_ite
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.val_add, Nat.add_mod_eq_ite, Nat.mod_eq_of_lt (show ↑a < n from a.2),
  Nat.mod_eq_of_lt (show ↑b < n from b.2)]
state_before: n✝ m n : ℕ
a b : Fin n
⊢ ↑(a + b) = if n ≤ ↑a + ↑b then ↑a + ↑b - n else ↑a + ↑b
Theorem: Nat.factorization_disjoint_of_coprime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simpa only [support_factorization] using
  disjoint_toFinset_iff_disjoint.mpr (coprime_factors_disjoint hab)
state_before: a b : ℕ
hab : coprime a b
⊢ _root_.Disjoint (factorization a).support (factorization b).support
Theorem: spectrum.neg_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: simp only [mem_neg, mem_iff, map_neg, ← neg_add', IsUnit.neg_iff, sub_neg_eq_add]
state_before: R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
x : R
⊢ x ∈ -σ a ↔ x ∈ σ (-a)
Theorem: PrimeMultiset.prod_ofNatMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: rw [coe_prod, to_ofNatMultiset]
state_before: v : Multiset ℕ
h : ∀ (p : ℕ), p ∈ v → Nat.Prime p
⊢ ↑(prod (ofNatMultiset v h)) = Multiset.prod v
Theorem: Quaternion.coe_normSq_add
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [star_add, ← self_mul_star, mul_add, add_mul, add_assoc, add_left_comm]
state_before: S : Type ?u.795476
T : Type ?u.795479
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ ↑(↑normSq (a + b)) = ↑(↑normSq a) + a * star b + b * star a + ↑(↑normSq b)
Theorem: Nat.lxor'_cancel_left
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← lxor'_assoc, lxor'_self, zero_lxor']
state_before: n m : ℕ
⊢ lxor' n (lxor' n m) = m
Theorem: Ordinal.le_cof_type
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rintro H d ⟨S, h, rfl⟩
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal
⊢ (∀ (S : Set α), Unbounded r S → c ≤ (#↑S)) → ∀ (b : Cardinal), b ∈ {c | ∃ S, Unbounded r S ∧ (#↑S) = c} → c ≤ b

tactic: exact H _ h
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal
H : ∀ (S : Set α), Unbounded r S → c ≤ (#↑S)
S : Set α
h : Unbounded r S
⊢ c ≤ (#↑S)
Theorem: Stream'.nth_odd
File: Mathlib/Data/Stream/Init.lean

tactic: rw [odd_eq, nth_even]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ nth (odd s) n = nth s (2 * n + 1)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ nth (tail s) (2 * n) = nth s (2 * n + 1)
Theorem: Lagrange.interpolate_singleton
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [interpolate_apply, sum_singleton, basis_singleton, mul_one]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
⊢ ↑(interpolate {i} v) r = ↑C (r i)
Theorem: Real.log_zpow
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: induction n
state_before: x✝ y x : ℝ
n : ℤ
⊢ log (x ^ n) = ↑n * log x

tactic: rw [zpow_negSucc, log_inv, log_pow, Int.cast_negSucc, Nat.cast_add_one, neg_mul_eq_neg_mul]
state_before: case negSucc
x✝ y x : ℝ
a✝ : ℕ
⊢ log (x ^ Int.negSucc a✝) = ↑(Int.negSucc a✝) * log x

tactic: rw [Int.ofNat_eq_coe, zpow_ofNat, log_pow, Int.cast_ofNat]
state_before: case ofNat
x✝ y x : ℝ
a✝ : ℕ
⊢ log (x ^ Int.ofNat a✝) = ↑(Int.ofNat a✝) * log x
Theorem: ContinuousLinearMap.comp_neg
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext x
state_before: R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_6
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_4
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_5
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type ?u.836875
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
⊢ comp g (-f) = -comp g f

tactic: simp
state_before: case h
R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_6
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_4
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_5
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type ?u.836875
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
x : M
⊢ ↑(comp g (-f)) x = ↑(-comp g f) x
Theorem: contDiffAt_of_subsingleton
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [Subsingleton.elim f fun _ => 0]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
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 ?u.54866
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
inst✝ : Subsingleton F
⊢ ContDiffAt 𝕜 n f x

tactic: exact contDiffAt_const
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
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 ?u.54866
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
inst✝ : Subsingleton F
⊢ ContDiffAt 𝕜 n (fun x => 0) x
Theorem: CategoryTheory.Limits.inr_inl_pushoutAssoc_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: trans f₂ ≫ l₁
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inl ≫ pushout.inr

tactic: congr 1
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.inr ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)

tactic: exact
  (pushoutPushoutLeftIsPushout g₁ g₂ g₃ g₄).comp_coconePointUniqueUpToIso_hom _
    WalkingCospan.left
state_before: case e_a
C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)

tactic: exact pushout.inr_desc _ _ _
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
    pushout.inl ≫ pushout.inr