tasksource/leandojo huggingface dataset:
Theorem: ContinuousMultilinearMap.norm_map_init_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [prod_univ_castSucc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => Ei (↑castSucc i)) (Ei (last n) →L[𝕜] G)
m : (i : Fin (Nat.succ n)) → Ei i
⊢ ‖f‖ * ((∏ i : Fin n, ‖init m i‖) * ‖m (last n)‖) = ‖f‖ * ∏ i : Fin (Nat.succ n), ‖m i‖

tactic: rfl
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => Ei (↑castSucc i)) (Ei (last n) →L[𝕜] G)
m : (i : Fin (Nat.succ n)) → Ei i
⊢ ‖f‖ * ((∏ i : Fin n, ‖init m i‖) * ‖m (last n)‖) = ‖f‖ * ((∏ i : Fin n, ‖m (↑castSucc i)‖) * ‖m (last n)‖)
Theorem: List.Sublist.erase_diff_erase_sublist
File: Std/Data/List/Lemmas.lean

tactic: if heq : b = a then
  simp [heq]
else
  simp [heq, erase_comm a]
  exact (erase_cons_head b _ ▸ h.erase b).erase_diff_erase_sublist
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁)

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

tactic: simp [heq, erase_comm a]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁)

tactic: exact (erase_cons_head b _ ▸ h.erase b).erase_diff_erase_sublist
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ List.diff (List.erase (List.erase l₂ b) a) (List.erase l₁ a) <+ List.diff (List.erase l₂ b) l₁
Theorem: imaginaryPart_smul
File: Mathlib/Data/Complex/Module.lean

tactic: conv_lhs =>
  rw [← re_add_im z]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
a : A
⊢ ↑ℑ (z • a) = z.re • ↑ℑ a + z.im • ↑ℜ a

tactic: simp [-re_add_im, add_smul, ← smul_smul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
a : A
⊢ ↑ℑ ((↑z.re + ↑z.im * I) • a) = z.re • ↑ℑ a + z.im • ↑ℜ a
Theorem: Set.image2_congr
File: Mathlib/Data/Set/NAry.lean

tactic: ext
state_before: α : Type u_1
α' : Type ?u.28943
β : Type u_2
β' : Type ?u.28949
γ : Type u_3
γ' : Type ?u.28955
δ : Type ?u.28958
δ' : Type ?u.28961
ε : Type ?u.28964
ε' : Type ?u.28967
ζ : Type ?u.28970
ζ' : Type ?u.28973
ν : Type ?u.28976
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : ∀ (a : α), a ∈ s → ∀ (b : β), b ∈ t → f a b = f' a b
⊢ image2 f s t = image2 f' s t

tactic: constructor <;> rintro ⟨a, b, ha, hb, rfl⟩ <;> refine' ⟨a, b, ha, hb, by rw [h a ha b hb]⟩
state_before: case h
α : Type u_1
α' : Type ?u.28943
β : Type u_2
β' : Type ?u.28949
γ : Type u_3
γ' : Type ?u.28955
δ : Type ?u.28958
δ' : Type ?u.28961
ε : Type ?u.28964
ε' : Type ?u.28967
ζ : Type ?u.28970
ζ' : Type ?u.28973
ν : Type ?u.28976
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : ∀ (a : α), a ∈ s → ∀ (b : β), b ∈ t → f a b = f' a b
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ image2 f' s t

tactic: rw [h a ha b hb]
state_before: α : Type u_1
α' : Type ?u.28943
β : Type u_2
β' : Type ?u.28949
γ : Type u_3
γ' : Type ?u.28955
δ : Type ?u.28958
δ' : Type ?u.28961
ε : Type ?u.28964
ε' : Type ?u.28967
ζ : Type ?u.28970
ζ' : Type ?u.28973
ν : Type ?u.28976
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
h : ∀ (a : α), a ∈ s → ∀ (b : β), b ∈ t → f a b = f' a b
a : α
b : β
ha : a ∈ s
hb : b ∈ t
⊢ f a b = f' a b
Theorem: CategoryTheory.Limits.Concrete.widePushout_exists_rep'
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: rcases Concrete.widePushout_exists_rep f x with (⟨y, rfl⟩ | ⟨i, y, rfl⟩)
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type v
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesColimit F (forget C)
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
x : (forget C).obj (widePushout B X f)
⊢ ∃ i y, (forget C).map (ι f i) y = x

tactic: inhabit α
state_before: case inl.intro
C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type v
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesColimit F (forget C)
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj B
⊢ ∃ i y_1, (forget C).map (ι f i) y_1 = (forget C).map (head f) y

tactic: use default, f _ y
state_before: case inl.intro
C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type v
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesColimit F (forget C)
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj B
inhabited_h : Inhabited α
⊢ ∃ i y_1, (forget C).map (ι f i) y_1 = (forget C).map (head f) y

tactic: simp only [← arrow_ι _ default, comp_apply]
state_before: case inl.intro
C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type v
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesColimit F (forget C)
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj B
inhabited_h : Inhabited α
⊢ (forget C).map (ι f default) ((forget C).map (f default) y) = (forget C).map (head f) y

tactic: use i, y
state_before: case inr.intro.intro
C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type v
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesColimit F (forget C)
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
i : α
y : (forget C).obj (X i)
⊢ ∃ i_1 y_1, (forget C).map (ι f i_1) y_1 = (forget C).map (ι f i) y
Theorem: Nat.add_sub_cancel
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.zero_add] at this
state_before: n m : Nat
this : n + m - (0 + m) = n
⊢ n + m - m = n

tactic: assumption
state_before: n m : Nat
this : n + m - m = n
⊢ n + m - m = n

tactic: rw [Nat.add_sub_add_right, Nat.sub_zero]
state_before: n m : Nat
⊢ n + m - (0 + m) = n
Theorem: hasFDerivAtFilter_pi'
File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

tactic: simp only [HasFDerivAtFilter, ContinuousLinearMap.coe_pi]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type ?u.422469
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type ?u.422564
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type ?u.422659
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_3
inst✝² : Fintype ι
F' : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ HasFDerivAtFilter Φ Φ' x L ↔ ∀ (i : ι), HasFDerivAtFilter (fun x => Φ x i) (comp (proj i) Φ') x L

tactic: exact isLittleO_pi
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type ?u.422469
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type ?u.422564
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type ?u.422659
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_3
inst✝² : Fintype ι
F' : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ ((fun x' => Φ x' - Φ x - ↑Φ' (x' - x)) =o[L] fun x' => x' - x) ↔
    ∀ (i : ι), (fun x' => Φ x' i - Φ x i - ↑(comp (proj i) Φ') (x' - x)) =o[L] fun x' => x' - x
Theorem: div_neg_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [division_def, mul_neg_iff]
state_before: ι : Type ?u.134372
α : Type u_1
β : Type ?u.134378
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b < 0 ↔ 0 < a ∧ b < 0 ∨ a < 0 ∧ 0 < b
Theorem: PGame.wf_isOption
File: Mathlib/SetTheory/Game/PGame.lean

tactic: induction' h with _ i _ j
state_before: x✝ x : PGame
IHl : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i)
IHr : ∀ (j : RightMoves x), Acc IsOption (moveRight x j)
y : PGame
h : IsOption y x
⊢ Acc IsOption y

tactic: exact IHl i
state_before: case moveLeft
x✝¹ x : PGame
IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i)
IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j)
y x✝ : PGame
i : LeftMoves x✝
IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i)
IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j)
⊢ Acc IsOption (moveLeft x✝ i)

tactic: exact IHr j
state_before: case moveRight
x✝¹ x : PGame
IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i)
IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j)
y x✝ : PGame
j : RightMoves x✝
IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i)
IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j)
⊢ Acc IsOption (moveRight x✝ j)
Theorem: Complex.sin_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sin_add]
state_before: x : ℂ
⊢ sin (x + ↑π / 2) = cos x
Theorem: OnePoint.nhds_infty_eq
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [← nhdsWithin_compl_infty_eq, nhdsWithin_compl_singleton_sup_pure]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ 𝓝 ∞ = map some (coclosedCompact X) ⊔ pure ∞
Theorem: Pell.yz_succ_succ
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: delta yz
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yz a1 (n + 2) + yz a1 n = ↑(2 * a) * yz a1 (n + 1)

tactic: rw [← Int.ofNat_add, ← Int.ofNat_mul, yn_succ_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ ↑(yn a1 (n + 2)) + ↑(yn a1 n) = ↑(2 * a) * ↑(yn a1 (n + 1))
Theorem: Nat.floor_of_nonpos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rintro rfl
state_before: F : Type ?u.26833
α : Type u_1
β : Type ?u.26839
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : a ≤ 0
⊢ a = 0 → ⌊a⌋₊ = 0

tactic: exact floor_zero
state_before: F : Type ?u.26833
α : Type u_1
β : Type ?u.26839
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
n : ℕ
ha : 0 ≤ 0
⊢ ⌊0⌋₊ = 0
Theorem: Pell.eq_of_xn_modEq_lem1
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: suffices xn a1 j % xn a1 n < xn a1 (j + 1) % xn a1 n from
  (lt_or_eq_of_le (Nat.le_of_succ_le_succ ij)).elim
    (fun h => lt_trans (eq_of_xn_modEq_lem1 h (le_of_lt jn)) this) fun h => by
    rw [h]; exact this
state_before: a : ℕ
a1 : 1 < a
i n j : ℕ
ij : i < j + 1
jn : j + 1 < n
⊢ xn a1 i % xn a1 n < xn a1 (j + 1) % xn a1 n

tactic: rw [Nat.mod_eq_of_lt (strictMono_x _ (Nat.lt_of_succ_lt jn)),
    Nat.mod_eq_of_lt (strictMono_x _ jn)]
state_before: a : ℕ
a1 : 1 < a
i n j : ℕ
ij : i < j + 1
jn : j + 1 < n
⊢ xn a1 j % xn a1 n < xn a1 (j + 1) % xn a1 n

tactic: exact strictMono_x _ (Nat.lt_succ_self _)
state_before: a : ℕ
a1 : 1 < a
i n j : ℕ
ij : i < j + 1
jn : j + 1 < n
⊢ xn a1 j < xn a1 (j + 1)

tactic: rw [h]
state_before: a : ℕ
a1 : 1 < a
i n j : ℕ
ij : i < j + 1
jn : j + 1 < n
this : xn a1 j % xn a1 n < xn a1 (j + 1) % xn a1 n
h : i = j
⊢ xn a1 i % xn a1 n < xn a1 (j + 1) % xn a1 n

tactic: exact this
state_before: a : ℕ
a1 : 1 < a
i n j : ℕ
ij : i < j + 1
jn : j + 1 < n
this : xn a1 j % xn a1 n < xn a1 (j + 1) % xn a1 n
h : i = j
⊢ xn a1 j % xn a1 n < xn a1 (j + 1) % xn a1 n
Theorem: Ideal.pow_mem_of_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: decide
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
ha : a ∈ I
n : ℕ
hn : 0 < n
⊢ ¬0 < Nat.zero
Theorem: Matrix.dotProduct_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct, mul_add, Finset.sum_add_distrib]
state_before: l : Type ?u.138074
m : Type u_1
n : Type ?u.138080
o : Type ?u.138083
m' : o → Type ?u.138088
n' : o → Type ?u.138093
R : Type ?u.138096
S : Type ?u.138099
α : Type v
β : Type w
γ : Type ?u.138106
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ u ⬝ᵥ (v + w) = u ⬝ᵥ v + u ⬝ᵥ w
Theorem: Polynomial.eval₂_C_X
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp [hp, hq]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
p q : R[X]
hp : eval₂ C X p = p
hq : eval₂ C X q = q
⊢ eval₂ C X (p + q) = p + q

tactic: rw [eval₂_monomial, ← smul_X_eq_monomial, C_mul']
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x✝ : S
n : ℕ
x : R
⊢ eval₂ C X (↑(monomial n) x) = ↑(monomial n) x
Theorem: Finset.mem_finsupp_iff
File: Mathlib/Data/Finset/Finsupp.lean

tactic: refine' mem_map.trans ⟨_, _⟩
state_before: ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι → Finset α
⊢ f ∈ Finset.finsupp s t ↔ f.support ⊆ s ∧ ∀ (i : ι), i ∈ s → ↑f i ∈ t i

tactic: rintro ⟨f, hf, rfl⟩
state_before: case refine'_1
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι → Finset α
⊢ (∃ a, a ∈ pi s t ∧ ↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } a = f) →
    f.support ⊆ s ∧ ∀ (i : ι), i ∈ s → ↑f i ∈ t i

tactic: refine' ⟨support_indicator_subset _ _, fun i hi => _⟩
state_before: case refine'_1.intro.intro
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
t : ι → Finset α
f : (i : ι) → i ∈ s → α
hf : f ∈ pi s t
⊢ (↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } f).support ⊆ s ∧
    ∀ (i : ι), i ∈ s → ↑(↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } f) i ∈ t i

tactic: convert mem_pi.1 hf i hi
state_before: case refine'_1.intro.intro
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
t : ι → Finset α
f : (i : ι) → i ∈ s → α
hf : f ∈ pi s t
i : ι
hi : i ∈ s
⊢ ↑(↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } f) i ∈ t i

tactic: exact indicator_of_mem hi _
state_before: case h.e'_4
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
t : ι → Finset α
f : (i : ι) → i ∈ s → α
hf : f ∈ pi s t
i : ι
hi : i ∈ s
⊢ ↑(↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } f) i = f i hi

tactic: refine' fun h => ⟨fun i _ => f i, mem_pi.2 h.2, _⟩
state_before: case refine'_2
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι → Finset α
⊢ (f.support ⊆ s ∧ ∀ (i : ι), i ∈ s → ↑f i ∈ t i) →
    ∃ a, a ∈ pi s t ∧ ↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } a = f

tactic: ext i
state_before: case refine'_2
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι → Finset α
h : f.support ⊆ s ∧ ∀ (i : ι), i ∈ s → ↑f i ∈ t i
⊢ (↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } fun i x => ↑f i) = f

tactic: exact ite_eq_left_iff.2 fun hi => (not_mem_support_iff.1 fun H => hi <| h.1 H).symm
state_before: case refine'_2.h
ι : Type u_2
α : Type u_1
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι → Finset α
h : f.support ⊆ s ∧ ∀ (i : ι), i ∈ s → ↑f i ∈ t i
i : ι
⊢ ↑(↑{ toFun := indicator s, inj' := (_ : Function.Injective fun f => indicator s f) } fun i x => ↑f i) i = ↑f i
Theorem: Fintype.card_congr'
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [h]
state_before: α✝ : Type ?u.5163
β✝ : Type ?u.5166
γ : Type ?u.5169
α β : Type u_1
inst✝¹ : Fintype α
inst✝ : Fintype β
h : α = β
⊢ α ≃ β
Theorem: Hyperreal.infinitesimal_iff_infinite_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [inv_inv]
state_before: x : ℝ*
h : x ≠ 0
⊢ Infinitesimal x ↔ Infinitesimal x⁻¹⁻¹
Theorem: NFA.mem_accepts
File: Mathlib/Computability/NFA.lean

tactic: rfl
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
x : List α
⊢ x ∈ accepts M ↔ ∃ S, S ∈ M.accept ∧ S ∈ evalFrom M M.start x
Theorem: Set.toFinset_empty
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.91377
γ : Type ?u.91380
s t : Set α
inst✝ : Fintype ↑∅
⊢ toFinset ∅ = ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.91377
γ : Type ?u.91380
s t : Set α
inst✝ : Fintype ↑∅
a✝ : α
⊢ a✝ ∈ toFinset ∅ ↔ a✝ ∈ ∅
Theorem: toIcoDiv_sub_eq_toIcoDiv_add'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [← sub_neg_eq_add, toIcoDiv_sub_eq_toIcoDiv_add, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoDiv hp (a - c) b = toIcoDiv hp a (b + c)
Theorem: RingHom.eq_liftOfRightInverse
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp_rw [← hh]
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : Ring C
f : A →+* B
f_inv : B → A
hf : Function.RightInverse f_inv ↑f
g : A →+* C
hg : ker f ≤ ker g
h : B →+* C
hh : comp h f = g
⊢ h = ↑(liftOfRightInverse f f_inv hf) { val := g, property := hg }

tactic: exact ((f.liftOfRightInverse f_inv hf).apply_symm_apply _).symm
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : Ring C
f : A →+* B
f_inv : B → A
hf : Function.RightInverse f_inv ↑f
g : A →+* C
hg : ker f ≤ ker g
h : B →+* C
hh : comp h f = g
⊢ h = ↑(liftOfRightInverse f f_inv hf) { val := comp h f, property := (_ : (fun g => ker f ≤ ker g) (comp h f)) }
Theorem: Set.Ioc_union_Ioc_symm
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [max_comm]
state_before: α : Type u_1
β : Type ?u.212353
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b a = Ioc (min a b) (max a b)

tactic: apply Ioc_union_Ioc <;> rw [max_comm] <;> exact min_le_max
state_before: α : Type u_1
β : Type ?u.212353
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b a = Ioc (min a b) (max b a)
Theorem: measurable_of_re_im
File: Mathlib/MeasureTheory/Function/SpecialFunctions/IsROrC.lean

tactic: convert Measurable.add (M := 𝕜) (IsROrC.measurable_ofReal.comp hre)
    ((IsROrC.measurable_ofReal.comp him).mul_const IsROrC.I)
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : Measurable fun x => ↑IsROrC.re (f x)
him : Measurable fun x => ↑IsROrC.im (f x)
⊢ Measurable f

tactic: exact (IsROrC.re_add_im _).symm
state_before: case h.e'_5.h
α : Type u_1
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : Measurable fun x => ↑IsROrC.re (f x)
him : Measurable fun x => ↑IsROrC.im (f x)
x✝ : α
⊢ f x✝ = (IsROrC.ofReal ∘ fun x => ↑IsROrC.re (f x)) x✝ + (IsROrC.ofReal ∘ fun x => ↑IsROrC.im (f x)) x✝ * IsROrC.I
Theorem: List.getElem?_eq_get?
File: Std/Data/List/Lemmas.lean

tactic: unfold getElem?
state_before: α : Type u_1
l : List α
i : Nat
⊢ l[i]? = get? l i

tactic: split
state_before: α : Type u_1
l : List α
i : Nat
⊢ (if h : (fun as i => i < length as) l i then some l[i] else none) = get? l i

tactic: exact (get?_eq_get ‹_›).symm
state_before: case inl
α : Type u_1
l : List α
i : Nat
h✝ : i < length l
⊢ some l[i] = get? l i

tactic: exact (get?_eq_none.2 <| Nat.not_lt.1 ‹_›).symm
state_before: case inr
α : Type u_1
l : List α
i : Nat
h✝ : ¬(fun as i => i < length as) l i
⊢ none = get? l i
Theorem: Rat.zero_of_num_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: have : q = q.num /. q.den := num_den.symm
state_before: a b c q : ℚ
hq : q.num = 0
⊢ q = 0

tactic: simpa [hq] using this
state_before: a b c q : ℚ
hq : q.num = 0
this : q = q.num /. ↑q.den
⊢ q = 0
Theorem: Nat.one_shiftLeft
File: Std/Data/Nat/Lemmas.lean

tactic: rw [shiftLeft_eq, Nat.one_mul]
state_before: n : Nat
⊢ 1 <<< n = 2 ^ n
Theorem: Ordnode.dual_node4R
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases m <;> simp [node4L, node4R, node3L, dual_node3R, dual_node', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ dual (node4R l x m y r) = node4L (dual r) y (dual m) x (dual l)
Theorem: vadd_vsub_vadd_cancel_right
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, vsub_self, add_zero]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
v₁ v₂ : G
p : P
⊢ v₁ +ᵥ p -ᵥ (v₂ +ᵥ p) = v₁ - v₂
Theorem: Real.abs_sinh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: cases le_total x 0 <;> simp [abs_of_nonneg, abs_of_nonpos, *]
state_before: x✝ y z x : ℝ
⊢ abs (sinh x) = sinh (abs x)
Theorem: add_tsub_add_eq_tsub_left
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm a b, add_comm a c, add_tsub_add_eq_tsub_right]
state_before: α : Type u_1
β : Type ?u.55470
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a + b - (a + c) = b - c
Theorem: PFun.preimage_comp
File: Mathlib/Data/PFun.lean

tactic: ext
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.55840
ε : Type ?u.55843
ι : Type ?u.55846
f✝ : α →. β
f : β →. γ
g : α →. β
s : Set γ
⊢ preimage (comp f g) s = preimage g (preimage f s)

tactic: simp_rw [mem_preimage, comp_apply, Part.mem_bind_iff, ← exists_and_right, ← exists_and_left]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.55840
ε : Type ?u.55843
ι : Type ?u.55846
f✝ : α →. β
f : β →. γ
g : α →. β
s : Set γ
x✝ : α
⊢ x✝ ∈ preimage (comp f g) s ↔ x✝ ∈ preimage g (preimage f s)

tactic: rw [exists_comm]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.55840
ε : Type ?u.55843
ι : Type ?u.55846
f✝ : α →. β
f : β →. γ
g : α →. β
s : Set γ
x✝ : α
⊢ (∃ y x, y ∈ s ∧ x ∈ g x✝ ∧ y ∈ f x) ↔ ∃ y x, (x ∈ s ∧ x ∈ f y) ∧ y ∈ g x✝

tactic: simp_rw [and_assoc, and_comm]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.55840
ε : Type ?u.55843
ι : Type ?u.55846
f✝ : α →. β
f : β →. γ
g : α →. β
s : Set γ
x✝ : α
⊢ (∃ b a, a ∈ s ∧ b ∈ g x✝ ∧ a ∈ f b) ↔ ∃ y x, (x ∈ s ∧ x ∈ f y) ∧ y ∈ g x✝