tasksource/leandojo huggingface dataset:
Theorem: univ_eq_singleton_of_card_one
File: Mathlib/Data/Fintype/Card.lean

tactic: symm
state_before: α✝ : Type ?u.60858
β : Type ?u.60861
γ : Type ?u.60864
α : Type u_1
inst✝ : Fintype α
x : α
h : Fintype.card α = 1
⊢ univ = {x}

tactic: apply eq_of_subset_of_card_le (subset_univ {x})
state_before: α✝ : Type ?u.60858
β : Type ?u.60861
γ : Type ?u.60864
α : Type u_1
inst✝ : Fintype α
x : α
h : Fintype.card α = 1
⊢ {x} = univ

tactic: apply le_of_eq
state_before: α✝ : Type ?u.60858
β : Type ?u.60861
γ : Type ?u.60864
α : Type u_1
inst✝ : Fintype α
x : α
h : Fintype.card α = 1
⊢ card univ ≤ card {x}

tactic: simp [h, Finset.card_univ]
state_before: case a
α✝ : Type ?u.60858
β : Type ?u.60861
γ : Type ?u.60864
α : Type u_1
inst✝ : Fintype α
x : α
h : Fintype.card α = 1
⊢ card univ = card {x}
Theorem: CategoryTheory.Limits.imageSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [imageSubobjectIso]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
⊢ (imageSubobjectIso f).hom ≫ image.ι f = arrow (imageSubobject f)
Theorem: List.erase_append_left
File: Std/Data/List/Lemmas.lean

tactic: simp [erase_eq_eraseP]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : a ∈ l₁
⊢ List.erase (l₁ ++ l₂) a = List.erase l₁ a ++ l₂

tactic: exact eraseP_append_left (by exact decide_eq_true rfl) l₂ h
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : a ∈ l₁
⊢ eraseP (fun b => decide (a = b)) (l₁ ++ l₂) = eraseP (fun b => decide (a = b)) l₁ ++ l₂

tactic: exact decide_eq_true rfl
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : a ∈ l₁
⊢ decide (a = a) = true
Theorem: Covby.Ioi_eq
File: Mathlib/Order/Cover.lean

tactic: rw [← Ioo_union_Ici_eq_Ioi h.lt, h.Ioo_eq, empty_union]
state_before: α : Type u_1
β : Type ?u.37583
inst✝ : LinearOrder α
a b c : α
h : a ⋖ b
⊢ Ioi a = Ici b
Theorem: Real.Angle.sin_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

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

tactic: exact Real.sin_pi_div_two_sub _
state_before: case h
x✝ : ℝ
⊢ sin (↑(π / 2) - ↑x✝) = cos ↑x✝
Theorem: StateT.run_modifyGet
File: src/lean/Init/Control/Lawful.lean

tactic: simp [modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, run]
state_before: m : Type u_1 → Type u_2
σ α : Type u_1
inst✝ : Monad m
f : σ → α × σ
s : σ
⊢ run (modifyGet f) s = pure ((f s).fst, (f s).snd)
Theorem: isUpperSet_iff_Ioi_subset
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [isUpperSet_iff_forall_lt, subset_def, @forall_swap (_ ∈ s)]
state_before: α : Type u_1
β : Type ?u.30000
γ : Type ?u.30003
ι : Sort ?u.30006
κ : ι → Sort ?u.30011
inst✝ : PartialOrder α
s : Set α
⊢ IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Ioi a ⊆ s
Theorem: Order.Ioc_pred_left_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [← Ioi_inter_Iic, Ioi_pred_of_not_isMin ha, Ici_inter_Iic]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ Ioc (pred a) b = Icc a b
Theorem: AffineSubspace.sSameSide_iff_exists_right
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [sSameSide_comm, sSameSide_iff_exists_left h, ← and_assoc, and_comm (a := y ∉ s), and_assoc]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.250138
P : Type u_3
P' : Type ?u.250144
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ SSameSide s x y ↔ ¬x ∈ s ∧ ¬y ∈ s ∧ ∃ p₁, p₁ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

tactic: simp_rw [SameRay.sameRay_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.250138
P : Type u_3
P' : Type ?u.250144
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ (¬x ∈ s ∧ ¬y ∈ s ∧ ∃ p₂_1, p₂_1 ∈ s ∧ SameRay R (y -ᵥ p₂) (x -ᵥ p₂_1)) ↔
    ¬x ∈ s ∧ ¬y ∈ s ∧ ∃ p₁, p₁ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
Theorem: List.formPerm_apply_nthLe_length
File: Mathlib/GroupTheory/Perm/List.lean

tactic: simp
state_before: α : Type ?u.667803
β : Type ?u.667806
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ length xs < length (x :: xs)

tactic: rw [nthLe_cons_length, formPerm_apply_getLast]
state_before: α : Type u_1
β : Type ?u.667806
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ ↑(formPerm (x :: xs)) (nthLe (x :: xs) (length xs) (_ : length xs < Nat.succ (length xs))) = x

tactic: rfl
state_before: case h
α : Type u_1
β : Type ?u.667806
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ length xs = length xs
Theorem: Composition.sigma_eq_iff_blocks_eq
File: Mathlib/Combinatorics/Composition.lean

tactic: refine' ⟨fun H => by rw [H], fun H => _⟩
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
⊢ c = c' ↔ c.snd.blocks = c'.snd.blocks

tactic: rcases c with ⟨n, c⟩
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
H : c.snd.blocks = c'.snd.blocks
⊢ c = c'

tactic: rcases c' with ⟨n', c'⟩
state_before: case mk
n✝ : ℕ
c✝ : Composition n✝
c' : (n : ℕ) × Composition n
n : ℕ
c : Composition n
H : { fst := n, snd := c }.snd.blocks = c'.snd.blocks
⊢ { fst := n, snd := c } = c'

tactic: have : n = n' := by rw [← c.blocks_sum, ← c'.blocks_sum, H]
state_before: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : { fst := n, snd := c }.snd.blocks = { fst := n', snd := c' }.snd.blocks
⊢ { fst := n, snd := c } = { fst := n', snd := c' }

tactic: induction this
state_before: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : { fst := n, snd := c }.snd.blocks = { fst := n', snd := c' }.snd.blocks
this : n = n'
⊢ { fst := n, snd := c } = { fst := n', snd := c' }

tactic: congr
state_before: case mk.mk.refl
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : { fst := n, snd := c }.snd.blocks = { fst := n, snd := c' }.snd.blocks
⊢ { fst := n, snd := c } = { fst := n, snd := c' }

tactic: ext1
state_before: case mk.mk.refl.e_snd
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : { fst := n, snd := c }.snd.blocks = { fst := n, snd := c' }.snd.blocks
⊢ c = c'

tactic: exact H
state_before: case mk.mk.refl.e_snd.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : { fst := n, snd := c }.snd.blocks = { fst := n, snd := c' }.snd.blocks
⊢ c.blocks = c'.blocks

tactic: rw [H]
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
H : c = c'
⊢ c.snd.blocks = c'.snd.blocks

tactic: rw [← c.blocks_sum, ← c'.blocks_sum, H]
state_before: n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : { fst := n, snd := c }.snd.blocks = { fst := n', snd := c' }.snd.blocks
⊢ n = n'
Theorem: add_div_eq_mul_add_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [right_distrib, div_mul_cancel _ hc]
state_before: α : Type u_1
β : Type ?u.6047
K : Type ?u.6050
inst✝ : DivisionSemiring α
a✝ b✝ c d a b : α
hc : c ≠ 0
⊢ (a + b / c) * c = a * c + b
Theorem: integral_sin_mul_cos₂
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simpa using integral_sin_pow_odd_mul_cos_pow 0 1
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x * cos x) = (cos a ^ 2 - cos b ^ 2) / 2
Theorem: Subfield.mem_sSup_of_directedOn
File: Mathlib/FieldTheory/Subfield.lean

tactic: haveI : Nonempty S := Sne.to_subtype
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
S : Set (Subfield K)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : K
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s

tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, Subtype.exists, exists_prop]
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
S : Set (Subfield K)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : K
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s
Theorem: Real.nnnorm_abs
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [nnnorm]
state_before: 𝓕 : Type ?u.1108272
𝕜 : Type ?u.1108275
α : Type ?u.1108278
ι : Type ?u.1108281
κ : Type ?u.1108284
E : Type ?u.1108287
F : Type ?u.1108290
G : Type ?u.1108293
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
⊢ ‖abs r‖₊ = ‖r‖₊
Theorem: StarSubalgebra.top_toSubalgebra
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: ext
state_before: F : Type ?u.651840
R : Type u_2
A : Type u_1
B : Type ?u.651849
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
⊢ ⊤.toSubalgebra = ⊤

tactic: simp
state_before: case h
F : Type ?u.651840
R : Type u_2
A : Type u_1
B : Type ?u.651849
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
x✝ : A
⊢ x✝ ∈ ⊤.toSubalgebra ↔ x✝ ∈ ⊤
Theorem: AffineSubspace.sOppSide_vadd_left_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [SOppSide, SOppSide, wOppSide_vadd_left_iff hv, vadd_mem_iff_mem_of_mem_direction hv]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.152354
P : Type u_3
P' : Type ?u.152360
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ direction s
⊢ SOppSide s (v +ᵥ x) y ↔ SOppSide s x y
Theorem: Convex.lipschitzWith_gauge
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: simp
state_before: 𝕜 : Type ?u.294666
E : Type u_1
F : Type ?u.294672
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r✝ : ℝ
x✝ : E
r : ℝ≥0
hc : Convex ℝ s
hr : 0 < r
hs : Metric.ball 0 ↑r ⊆ s
this : Absorbent ℝ (Metric.ball 0 ↑r)
x y : E
⊢ gauge s x = gauge s (y + (x - y))

tactic: rw [dist_eq_norm, div_eq_inv_mul, NNReal.coe_inv]
state_before: 𝕜 : Type ?u.294666
E : Type u_1
F : Type ?u.294672
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r✝ : ℝ
x✝ : E
r : ℝ≥0
hc : Convex ℝ s
hr : 0 < r
hs : Metric.ball 0 ↑r ⊆ s
this : Absorbent ℝ (Metric.ball 0 ↑r)
x y : E
⊢ gauge s y + ‖x - y‖ / ↑r = gauge s y + ↑r⁻¹ * dist x y
Theorem: iSup_iSup_eq_left
File: Mathlib/Order/CompleteLattice.lean

tactic: rintro rfl
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.97502
γ : Type ?u.97505
ι : Sort ?u.97508
ι' : Sort ?u.97511
κ : ι → Sort ?u.97516
κ' : ι' → Sort ?u.97521
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b✝ : α
b : β
f : (x : β) → x = b → α
c : β
⊢ ∀ (i : c = b), f c i ≤ f b (_ : b = b)

tactic: rfl
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.97502
γ : Type ?u.97505
ι : Sort ?u.97508
ι' : Sort ?u.97511
κ : ι → Sort ?u.97516
κ' : ι' → Sort ?u.97521
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
c : β
f : (x : β) → x = c → α
⊢ f c (_ : c = c) ≤ f c (_ : c = c)
Theorem: Semiquot.eq_pure
File: Mathlib/Data/Semiquot.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.15504
q : Semiquot α
p : IsPure q
a : α
⊢ a ∈ q ↔ a ∈ pure (get q p)

tactic: exact ⟨fun h => p _ h _ (get_mem _), fun e => e.symm ▸ get_mem _⟩
state_before: α : Type u_1
β : Type ?u.15504
q : Semiquot α
p : IsPure q
a : α
⊢ a ∈ q ↔ a = get q p
Theorem: exists_pos_mul_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: have : 0 < a / max (b + 1) 1 := div_pos h (lt_max_iff.2 (Or.inr zero_lt_one))
state_before: ι : Type ?u.109118
α : Type u_1
β : Type ?u.109124
inst✝ : LinearOrderedSemifield α
a✝ b✝ c d e : α
m n : ℤ
a : α
h : 0 < a
b : α
⊢ ∃ c, 0 < c ∧ b * c < a

tactic: refine' ⟨a / max (b + 1) 1, this, _⟩
state_before: ι : Type ?u.109118
α : Type u_1
β : Type ?u.109124
inst✝ : LinearOrderedSemifield α
a✝ b✝ c d e : α
m n : ℤ
a : α
h : 0 < a
b : α
this : 0 < a / max (b + 1) 1
⊢ ∃ c, 0 < c ∧ b * c < a

tactic: rw [← lt_div_iff this, div_div_cancel' h.ne']
state_before: ι : Type ?u.109118
α : Type u_1
β : Type ?u.109124
inst✝ : LinearOrderedSemifield α
a✝ b✝ c d e : α
m n : ℤ
a : α
h : 0 < a
b : α
this : 0 < a / max (b + 1) 1
⊢ b * (a / max (b + 1) 1) < a

tactic: exact lt_max_iff.2 (Or.inl <| lt_add_one _)
state_before: ι : Type ?u.109118
α : Type u_1
β : Type ?u.109124
inst✝ : LinearOrderedSemifield α
a✝ b✝ c d e : α
m n : ℤ
a : α
h : 0 < a
b : α
this : 0 < a / max (b + 1) 1
⊢ b < max (b + 1) 1
Theorem: List.get_eq_iff
File: Mathlib/Data/List/Basic.lean

tactic: rw [get?_eq_some]
state_before: ι : Type ?u.106668
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : Fin (length l)
x : α
⊢ get l n = x ↔ get? l ↑n = some x

tactic: simp [n.2]
state_before: ι : Type ?u.106668
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : Fin (length l)
x : α
⊢ get l n = x ↔ ∃ h, get l { val := ↑n, isLt := h } = x
Theorem: abs_real_inner_div_norm_mul_norm_le_one
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [abs_div, abs_mul, abs_norm, abs_norm]
state_before: 𝕜 : Type ?u.3138511
E : Type ?u.3138514
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ abs (inner x y / (‖x‖ * ‖y‖)) ≤ 1

tactic: exact div_le_one_of_le (abs_real_inner_le_norm x y) (mul_nonneg (norm_nonneg _) (norm_nonneg _))
state_before: 𝕜 : Type ?u.3138511
E : Type ?u.3138514
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ abs (inner x y) / (‖x‖ * ‖y‖) ≤ 1
Theorem: List.rotate'_eq_drop_append_take
File: Mathlib/Data/List/Rotate.lean

tactic: simp [drop_append_of_le_length h]
state_before: α : Type u
n : ℕ
h : n ≤ length []
⊢ rotate' [] n = drop n [] ++ take n []

tactic: simp [take_append_of_le_length h]
state_before: α : Type u
l : List α
h : 0 ≤ length l
⊢ rotate' l 0 = drop 0 l ++ take 0 l

tactic: have hnl : n ≤ l.length := le_of_succ_le_succ h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
⊢ rotate' (a :: l) (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)

tactic: have hnl' : n ≤ (l ++ [a]).length := by
  rw [length_append, length_cons, List.length]; exact le_of_succ_le h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
hnl : n ≤ length l
⊢ rotate' (a :: l) (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)

tactic: rw [rotate'_cons_succ, rotate'_eq_drop_append_take hnl', drop, take,
    drop_append_of_le_length hnl, take_append_of_le_length hnl]
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
hnl : n ≤ length l
hnl' : n ≤ length (l ++ [a])
⊢ rotate' (a :: l) (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)

tactic: simp
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
hnl : n ≤ length l
hnl' : n ≤ length (l ++ [a])
⊢ drop n l ++ [a] ++ take n l = drop n l ++ a :: take n l

tactic: rw [length_append, length_cons, List.length]
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
hnl : n ≤ length l
⊢ n ≤ length (l ++ [a])

tactic: exact le_of_succ_le h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ length (a :: l)
hnl : n ≤ length l
⊢ n ≤ length l + succ 0
Theorem: Matrix.TransvectionStruct.toMatrix_reindexEquiv_prod
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: induction' L with t L IH
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.115849
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
L : List (TransvectionStruct n R)
⊢ List.prod (List.map (toMatrix ∘ reindexEquiv e) L) = ↑(reindexAlgEquiv R e) (List.prod (List.map toMatrix L))

tactic: simp
state_before: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.115849
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
⊢ List.prod (List.map (toMatrix ∘ reindexEquiv e) []) = ↑(reindexAlgEquiv R e) (List.prod (List.map toMatrix []))

tactic: simp only [toMatrix_reindexEquiv, IH, Function.comp_apply, List.prod_cons, mul_eq_mul,
  reindexAlgEquiv_apply, List.map]
state_before: case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.115849
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : List.prod (List.map (toMatrix ∘ reindexEquiv e) L) = ↑(reindexAlgEquiv R e) (List.prod (List.map toMatrix L))
⊢ List.prod (List.map (toMatrix ∘ reindexEquiv e) (t :: L)) =
    ↑(reindexAlgEquiv R e) (List.prod (List.map toMatrix (t :: L)))

tactic: exact (reindexAlgEquiv_mul _ _ _ _).symm
state_before: case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.115849
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : List.prod (List.map (toMatrix ∘ reindexEquiv e) L) = ↑(reindexAlgEquiv R e) (List.prod (List.map toMatrix L))
⊢ ↑(reindex e e) (toMatrix t) ⬝ ↑(reindex e e) (List.prod (List.map toMatrix L)) =
    ↑(reindex e e) (toMatrix t ⬝ List.prod (List.map toMatrix L))
Theorem: CategoryTheory.Limits.biprod.isoProd_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: apply biprod.hom_ext' <;> apply prod.hom_ext <;> simp [biprod.isoProd]
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).hom = prod.lift fst snd
Theorem: Ideal.eval₂_C_mk_eq_zero
File: Mathlib/RingTheory/Polynomial/Quotient.lean

tactic: intro a ha
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ ∀ (f : R[X]), f ∈ map C I → ↑(eval₂RingHom (RingHom.comp C (Quotient.mk I)) X) f = 0

tactic: rw [← sum_monomial_eq a]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
⊢ ↑(eval₂RingHom (RingHom.comp C (Quotient.mk I)) X) a = 0

tactic: dsimp
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
⊢ ↑(eval₂RingHom (RingHom.comp C (Quotient.mk I)) X) (sum a fun n a => ↑(monomial n) a) = 0

tactic: rw [eval₂_sum]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
⊢ eval₂ (RingHom.comp C (Quotient.mk I)) X (sum a fun n a => ↑(monomial n) a) = 0

tactic: refine' Finset.sum_eq_zero fun n _ => _
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
⊢ (sum a fun n a => eval₂ (RingHom.comp C (Quotient.mk I)) X (↑(monomial n) a)) = 0

tactic: dsimp
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
⊢ (fun n a => eval₂ (RingHom.comp C (Quotient.mk I)) X (↑(monomial n) a)) n (coeff a n) = 0

tactic: rw [eval₂_monomial (C.comp (Quotient.mk I)) X]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
⊢ eval₂ (RingHom.comp C (Quotient.mk I)) X (↑(monomial n) (coeff a n)) = 0

tactic: refine' mul_eq_zero_of_left (Polynomial.ext fun m => _) (X ^ n)
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
⊢ ↑(RingHom.comp C (Quotient.mk I)) (coeff a n) * X ^ n = 0

tactic: erw [coeff_C]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
m : ℕ
⊢ coeff (↑(RingHom.comp C (Quotient.mk I)) (coeff a n)) m = coeff 0 m

tactic: by_cases h : m = 0
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
m : ℕ
⊢ (if m = 0 then ↑(Quotient.mk I) (coeff a n) else 0) = coeff 0 m

tactic: simpa [h] using Quotient.eq_zero_iff_mem.2 ((mem_map_C_iff.1 ha) n)
state_before: case pos
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
m : ℕ
h : m = 0
⊢ (if m = 0 then ↑(Quotient.mk I) (coeff a n) else 0) = coeff 0 m

tactic: simp [h]
state_before: case neg
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a : R[X]
ha : a ∈ map C I
n : ℕ
x✝ : n ∈ support a
m : ℕ
h : ¬m = 0
⊢ (if m = 0 then ↑(Quotient.mk I) (coeff a n) else 0) = coeff 0 m
Theorem: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: simp_rw [toMeasureOfZeroLE, Measure.ofMeasurable_apply _ hj₁, toMeasureOfZeroLE',
  s.restrict_apply hi₁ hj₁, Set.inter_comm]
state_before: α : Type u_1
β : Type ?u.708976
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hi : restrict 0 i ≤ restrict s i
hi₁ : MeasurableSet i
hj₁ : MeasurableSet j
⊢ ↑↑(toMeasureOfZeroLE s i hi₁ hi) j = ↑{ val := ↑s (i ∩ j), property := (_ : 0 ≤ ↑s (i ∩ j)) }
Theorem: Nat.digits_zero
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | ⟨_ | ⟨_⟩⟩) <;> simp [digits, digitsAux0, digitsAux1]
state_before: n b : ℕ
⊢ digits b 0 = []
Theorem: Complex.arg_conj_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: by_cases h : arg x = π <;> simp [arg_conj, h]
state_before: x : ℂ
⊢ ↑(arg (↑(starRingEnd ℂ) x)) = -↑(arg x)
Theorem: mul_sub_right_distrib
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simpa only [sub_eq_add_neg, neg_mul_eq_neg_mul] using add_mul a (-b) c
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c : α
⊢ (a - b) * c = a * c - b * c
Theorem: derivWithin_congr_set
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp only [derivWithin, fderivWithin_congr_set h]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : s =ᶠ[𝓝 x] t
⊢ derivWithin f s x = derivWithin f t x