tasksource/leandojo huggingface dataset:
Theorem: Set.countable_setOf_finite_subset
File: Mathlib/Data/Set/Countable.lean

tactic: haveI := hs.to_subtype
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
⊢ Set.Countable {t | Set.Finite t ∧ t ⊆ s}

tactic: refine' Countable.mono _ (countable_range fun t : Finset s => Subtype.val '' (t : Set s))
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
this : Countable ↑s
⊢ Set.Countable {t | Set.Finite t ∧ t ⊆ s}

tactic: rintro t ⟨ht, hts⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
this : Countable ↑s
⊢ {t | Set.Finite t ∧ t ⊆ s} ⊆ range fun t => Subtype.val '' ↑t

tactic: lift t to Set s using hts
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
this : Countable ↑s
t : Set α
ht : Set.Finite t
hts : t ⊆ s
⊢ t ∈ range fun t => Subtype.val '' ↑t

tactic: lift t to Finset s using ht.of_finite_image (Subtype.val_injective.injOn _)
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
this : Countable ↑s
t : Set ↑s
ht : Set.Finite ((fun x x_1 => x '' x_1) Subtype.val t)
⊢ (fun x x_1 => x '' x_1) Subtype.val t ∈ range fun t => Subtype.val '' ↑t

tactic: exact mem_range_self _
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
this : Countable ↑s
t : Finset ↑s
ht : Set.Finite ((fun x x_1 => x '' x_1) Subtype.val ↑t)
⊢ (fun x x_1 => x '' x_1) Subtype.val ↑t ∈ range fun t => Subtype.val '' ↑t
Theorem: Real.rpow_sub_nat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simpa using rpow_sub_int hx y n
state_before: x✝ y✝ z x : ℝ
hx : x ≠ 0
y : ℝ
n : ℕ
⊢ x ^ (y - ↑n) = x ^ y / x ^ n
Theorem: mul_lt_of_lt_one_left
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : MulPosStrictMono α
hb : 0 < b
h : a < 1
⊢ a * b < b
Theorem: Subsemigroup.mem_sup_left
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: have : S ≤ S ⊔ T := le_sup_left
state_before: ι : Sort ?u.7679
M : Type u_1
A : Type ?u.7685
B : Type ?u.7688
inst✝ : Mul M
S T : Subsemigroup M
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T

tactic: tauto
state_before: ι : Sort ?u.7679
M : Type u_1
A : Type ?u.7685
B : Type ?u.7688
inst✝ : Mul M
S T : Subsemigroup M
this : S ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T
Theorem: Finset.sdiff_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← sdiff_singleton_eq_erase, sdiff_sdiff_eq_sdiff_union (singleton_subset_iff.2 h), insert_eq,
  union_comm]
state_before: α : Type u_1
β : Type ?u.269737
γ : Type ?u.269740
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
⊢ s \ erase t a = insert a (s \ t)
Theorem: Set.Subsingleton.einfsep
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [einfsep_top]
state_before: α : Type u_1
β : Type ?u.15427
inst✝ : EDist α
x y : α
s t : Set α
hs : Set.Subsingleton s
⊢ Set.einfsep s = ⊤

tactic: exact fun _ hx _ hy hxy => (hxy <| hs hx hy).elim
state_before: α : Type u_1
β : Type ?u.15427
inst✝ : EDist α
x y : α
s t : Set α
hs : Set.Subsingleton s
⊢ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → edist x y = ⊤
Theorem: Nat.factorial_eq_one
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: apply Iff.intro <;> intro
state_before: m n : ℕ
⊢ n ! = 1 ↔ n ≤ 1

tactic: rw [← not_lt, ← one_lt_factorial, ‹n ! = 1›]
state_before: case mp
m n : ℕ
a✝ : n ! = 1
⊢ n ≤ 1

tactic: apply lt_irrefl
state_before: case mp
m n : ℕ
a✝ : n ! = 1
⊢ ¬1 < 1

tactic: cases ‹n ≤ 1›
state_before: case mpr
m n : ℕ
a✝ : n ≤ 1
⊢ n ! = 1

tactic: rfl
state_before: case mpr.refl
m : ℕ
⊢ 1! = 1

tactic: cases ‹n ≤ 0›
state_before: case mpr.step
m n : ℕ
a✝ : Nat.le n 0
⊢ n ! = 1

tactic: rfl
state_before: case mpr.step.refl
m : ℕ
⊢ 0! = 1
Theorem: nhdsSet_inj_iff
File: Mathlib/Topology/Separation.lean

tactic: simp_rw [le_antisymm_iff]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s t : Set α
⊢ 𝓝ˢ s = 𝓝ˢ t ↔ s = t

tactic: exact and_congr nhdsSet_le_iff nhdsSet_le_iff
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s t : Set α
⊢ 𝓝ˢ s ≤ 𝓝ˢ t ∧ 𝓝ˢ t ≤ 𝓝ˢ s ↔ s ≤ t ∧ t ≤ s
Theorem: Nat.div_le_self
File: src/lean/Init/Data/Nat/Div.lean

tactic: induction n using Nat.strongInductionOn with
| ind n ih =>
  rw [div_eq]
  cases (inferInstance : Decidable (0 < k ∧ k ≤ n)) with
  | isFalse h => simp [h]
  | isTrue h =>
    suffices (n - k) / k + 1 ≤ n by simp [h, this]
    have ⟨hK, hKN⟩ := h
    have hSub : n - k < n := sub_lt (Nat.lt_of_lt_of_le hK hKN) hK
    have : (n - k) / k ≤ n - k := ih (n - k) hSub
    exact succ_le_of_lt (Nat.lt_of_le_of_lt this hSub)
state_before: n k : Nat
⊢ n / k ≤ n

tactic: rw [div_eq]
state_before: case ind
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
⊢ n / k ≤ n

tactic: cases (inferInstance : Decidable (0 < k ∧ k ≤ n)) with
| isFalse h => simp [h]
| isTrue h =>
  suffices (n - k) / k + 1 ≤ n by simp [h, this]
  have ⟨hK, hKN⟩ := h
  have hSub : n - k < n := sub_lt (Nat.lt_of_lt_of_le hK hKN) hK
  have : (n - k) / k ≤ n - k := ih (n - k) hSub
  exact succ_le_of_lt (Nat.lt_of_le_of_lt this hSub)
state_before: case ind
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
⊢ ite (0 < k ∧ k ≤ n) ((n - k) / k + 1) 0 ≤ n

tactic: simp [h]
state_before: case ind.isFalse
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : ¬(0 < k ∧ k ≤ n)
⊢ ite (0 < k ∧ k ≤ n) ((n - k) / k + 1) 0 ≤ n

tactic: suffices (n - k) / k + 1 ≤ n by simp [h, this]
state_before: case ind.isTrue
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
⊢ ite (0 < k ∧ k ≤ n) ((n - k) / k + 1) 0 ≤ n

tactic: have ⟨hK, hKN⟩ := h
state_before: case ind.isTrue
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
⊢ (n - k) / k + 1 ≤ n

tactic: have hSub : n - k < n := sub_lt (Nat.lt_of_lt_of_le hK hKN) hK
state_before: case ind.isTrue
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
hK : 0 < k
hKN : k ≤ n
⊢ (n - k) / k + 1 ≤ n

tactic: have : (n - k) / k ≤ n - k := ih (n - k) hSub
state_before: case ind.isTrue
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
hK : 0 < k
hKN : k ≤ n
hSub : n - k < n
⊢ (n - k) / k + 1 ≤ n

tactic: exact succ_le_of_lt (Nat.lt_of_le_of_lt this hSub)
state_before: case ind.isTrue
k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
hK : 0 < k
hKN : k ≤ n
hSub : n - k < n
this : (n - k) / k ≤ n - k
⊢ (n - k) / k + 1 ≤ n

tactic: simp [h, this]
state_before: k n : Nat
ih : ∀ (m : Nat), m < n → m / k ≤ m
h : 0 < k ∧ k ≤ n
this : (n - k) / k + 1 ≤ n
⊢ ite (0 < k ∧ k ≤ n) ((n - k) / k + 1) 0 ≤ n
Theorem: AffineBasis.toMatrix_inv_vecMul_toMatrix
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: have hu := b.isUnit_toMatrix b₂
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
⊢ vecMul (↑(coords b) x) (toMatrix b ↑b₂)⁻¹ = ↑(coords b₂) x

tactic: rw [Matrix.isUnit_iff_isUnit_det] at hu
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (toMatrix b ↑b₂)
⊢ vecMul (↑(coords b) x) (toMatrix b ↑b₂)⁻¹ = ↑(coords b₂) x

tactic: rw [← b.toMatrix_vecMul_coords b₂, Matrix.vecMul_vecMul, Matrix.mul_nonsing_inv _ hu,
  Matrix.vecMul_one]
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (det (toMatrix b ↑b₂))
⊢ vecMul (↑(coords b) x) (toMatrix b ↑b₂)⁻¹ = ↑(coords b₂) x
Theorem: LinearMap.iSup_range_stdBasis_le_iInf_ker_proj
File: Mathlib/LinearAlgebra/StdBasis.lean

tactic: refine' iSup_le fun i => iSup_le fun hi => range_le_iff_comap.2 _
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
⊢ (⨆ (i : ι) (_ : i ∈ I), range (stdBasis R φ i)) ≤ ⨅ (i : ι) (_ : i ∈ J), ker (proj i)

tactic: simp only [←ker_comp, eq_top_iff, SetLike.le_def, mem_ker, comap_iInf, mem_iInf]
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
i : ι
hi : i ∈ I
⊢ comap (stdBasis R φ i) (⨅ (i : ι) (_ : i ∈ J), ker (proj i)) = ⊤

tactic: rintro b - j hj
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
i : ι
hi : i ∈ I
⊢ ∀ ⦃x : φ i⦄, x ∈ ⊤ → ∀ (i_1 : ι), i_1 ∈ J → ↑(comp (proj i_1) (stdBasis R φ i)) x = 0

tactic: rw [proj_stdBasis_ne R φ j i, zero_apply]
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
i : ι
hi : i ∈ I
b : φ i
j : ι
hj : j ∈ J
⊢ ↑(comp (proj j) (stdBasis R φ i)) b = 0

tactic: rintro rfl
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
i : ι
hi : i ∈ I
b : φ i
j : ι
hj : j ∈ J
⊢ j ≠ i

tactic: exact h.le_bot ⟨hi, hj⟩
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
h : Disjoint I J
j : ι
hj : j ∈ J
hi : j ∈ I
b : φ j
⊢ False
Theorem: RelIso.rel_symm_apply
File: Mathlib/Order/RelIso/Basic.lean

tactic: rw [← e.map_rel_iff, e.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82847
δ : Type ?u.82850
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e : r ≃r s
x : α
y : β
⊢ r x (↑(RelIso.symm e) y) ↔ s (↑e x) y
Theorem: hyperoperation_ge_four_zero
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: induction' k with kk kih
state_before: n k : ℕ
⊢ hyperoperation (n + 4) 0 k = if Even k then 1 else 0

tactic: rw [hyperoperation_ge_three_eq_one]
state_before: case zero
n : ℕ
⊢ hyperoperation (n + 4) 0 Nat.zero = if Even Nat.zero then 1 else 0

tactic: simp only [even_zero, if_true]
state_before: case zero
n : ℕ
⊢ 1 = if Even Nat.zero then 1 else 0

tactic: rw [hyperoperation_recursion]
state_before: case succ
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
⊢ hyperoperation (n + 4) 0 (Nat.succ kk) = if Even (Nat.succ kk) then 1 else 0

tactic: rw [kih]
state_before: case succ
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
⊢ hyperoperation (n + 3) 0 (hyperoperation (n + 3 + 1) 0 kk) = if Even (Nat.succ kk) then 1 else 0

tactic: simp_rw [Nat.even_add_one]
state_before: case succ
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
⊢ hyperoperation (n + 3) 0 (if Even kk then 1 else 0) = if Even (Nat.succ kk) then 1 else 0

tactic: split_ifs
state_before: case succ
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
⊢ hyperoperation (n + 3) 0 (if Even kk then 1 else 0) = if ¬Even kk then 1 else 0

tactic: exact hyperoperation_ge_two_eq_self (n + 1) 0
state_before: case succ.inl
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
h✝ : Even kk
⊢ hyperoperation (n + 3) 0 1 = 0

tactic: exact hyperoperation_ge_three_eq_one n 0
state_before: case succ.inr
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
h✝ : ¬Even kk
⊢ hyperoperation (n + 3) 0 0 = 1
Theorem: CategoryTheory.Adjunction.unit_rightAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: apply Quiver.Hom.op_inj
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
⊢ adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) = adj2.unit.app x

tactic: convert
  leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
    (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op = (adj2.unit.app x).op

tactic: all_goals {
  simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
    opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
    Equiv.symm_symm, homEquiv_unit]
  erw [Functor.map_id]
  rw [Category.comp_id]
  rfl }
state_before: case h.e'_2.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ : ((G'.obj (F.obj x)).op ⟶ ((𝟭 C).obj x).op) = ((Functor.op G').obj ((Functor.op F).obj x.op) ⟶ (𝟭 Cᵒᵖ).obj x.op)
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op =
    (leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app
        ((Functor.op F).obj x.op) ≫
      (opAdjointOpOfAdjoint G F adj1).counit.app x.op

case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ : ((G'.obj (F.obj x)).op ⟶ ((𝟭 C).obj x).op) = ((Functor.op G').obj ((Functor.op F).obj x.op) ⟶ (𝟭 Cᵒᵖ).obj x.op)
⊢ (adj2.unit.app x).op = (opAdjointOpOfAdjoint G' F adj2).counit.app x.op
Theorem: MvPolynomial.map_expand
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: simp [expand, map_bind₁]
state_before: σ : Type u_3
τ : Type ?u.204198
R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
p : ℕ
φ : MvPolynomial σ R
⊢ ↑(map f) (↑(expand p) φ) = ↑(expand p) (↑(map f) φ)
Theorem: Stream'.WSeq.LiftRel.refl
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Computation.LiftRel (LiftRelO R fun x x_1 => x = x_1) (destruct s) (destruct t)

tactic: apply Computation.LiftRel.refl
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Computation.LiftRel (LiftRelO R fun x x_1 => x = x_1) (destruct s) (destruct s)

tactic: intro a
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Reflexive (LiftRelO R fun x x_1 => x = x_1)

tactic: cases' a with a
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : Option (α × WSeq α)
⊢ LiftRelO R (fun x x_1 => x = x_1) a a

tactic: simp
state_before: case H.none
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ LiftRelO R (fun x x_1 => x = x_1) none none

tactic: cases a
state_before: case H.some
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : α × WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some a) (some a)

tactic: simp only [LiftRelO, and_true]
state_before: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some (fst✝, snd✝)) (some (fst✝, snd✝))

tactic: apply H
state_before: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ R fst✝ fst✝
Theorem: Filter.Germ.min_def
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: cases' le_total (a : β*) b with h h
state_before: α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : Germ (↑φ) β
a b : α → β
⊢ min ↑a ↑b = map₂ min ↑a ↑b

tactic: rw [min_eq_left h, map₂_coe, coe_eq]
state_before: case inl
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : Germ (↑φ) β
a b : α → β
h : ↑a ≤ ↑b
⊢ min ↑a ↑b = map₂ min ↑a ↑b

tactic: exact h.mono fun i hi => (min_eq_left hi).symm
state_before: case inl
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : Germ (↑φ) β
a b : α → β
h : ↑a ≤ ↑b
⊢ a =ᶠ[↑φ] fun x => min (a x) (b x)

tactic: rw [min_eq_right h, map₂_coe, coe_eq]
state_before: case inr
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : Germ (↑φ) β
a b : α → β
h : ↑b ≤ ↑a
⊢ min ↑a ↑b = map₂ min ↑a ↑b

tactic: exact h.mono fun i hi => (min_eq_right hi).symm
state_before: case inr
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : Germ (↑φ) β
a b : α → β
h : ↑b ≤ ↑a
⊢ b =ᶠ[↑φ] fun x => min (a x) (b x)
Theorem: Primrec.decode₂
File: Mathlib/Computability/Primrec.lean

tactic: exact encode_iff.mpr snd
state_before: α : Type u_1
β : Type ?u.140489
γ : Type ?u.140492
δ : Type ?u.140495
σ : Type ?u.140498
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
⊢ Primrec₂ fun p a => encode a

tactic: exact fst.comp fst
state_before: α : Type u_1
β : Type ?u.140489
γ : Type ?u.140492
δ : Type ?u.140495
σ : Type ?u.140498
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
⊢ Primrec₂ fun p a => p.fst
Theorem: CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [pushoutZeroZeroIso]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ pushout.inl ≫ (pushoutZeroZeroIso X Y).hom = coprod.inl

tactic: simp
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ pushout.inl ≫
      (colimit.isoColimitCocone
          { cocone := PushoutCocone.mk coprod.inl coprod.inr (_ : 0 ≫ coprod.inl = 0 ≫ coprod.inr),
            isColimit :=
              isPushoutOfIsInitialIsCoproduct coprod.inl coprod.inr 0 0 HasZeroObject.zeroIsInitial
                (coprodIsCoprod X Y) }).hom =
    coprod.inl
Theorem: Complex.sin_surjective
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: intro x
state_before: ⊢ Function.Surjective sin

tactic: rcases cos_surjective x with ⟨z, rfl⟩
state_before: x : ℂ
⊢ ∃ a, sin a = x

tactic: exact ⟨z + π / 2, sin_add_pi_div_two z⟩
state_before: case intro
z : ℂ
⊢ ∃ a, sin a = cos z
Theorem: PolyEquivTensor.toFunLinear_algebraMap_tmul_one
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: rw [toFunLinear_tmul_apply, toFunBilinear_apply_apply, Polynomial.aeval_one, algebraMap_smul,
  Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one]
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
r : R
⊢ ↑(toFunLinear R A) (↑(algebraMap R A) r ⊗ₜ[R] 1) = ↑(algebraMap R A[X]) r
Theorem: Nat.bit1_mod_bit0
File: Mathlib/Data/Nat/Parity.lean

tactic: have h₁ := congr_arg bit1 (Nat.div_add_mod n m)
state_before: m n : ℕ
⊢ bit1 n % bit0 m = bit1 (n % m)

tactic: rw [bit1_add, bit0_eq_two_mul, ← mul_assoc, ← bit0_eq_two_mul] at h₁
state_before: m n : ℕ
h₁ : bit1 (m * (n / m) + n % m) = bit1 n
⊢ bit1 n % bit0 m = bit1 (n % m)

tactic: have h₂ := Nat.div_add_mod (bit1 n) (bit0 m)
state_before: m n : ℕ
h₁ : bit0 m * (n / m) + bit1 (n % m) = bit1 n
⊢ bit1 n % bit0 m = bit1 (n % m)

tactic: rw [bit1_div_bit0] at h₂
state_before: m n : ℕ
h₁ : bit0 m * (n / m) + bit1 (n % m) = bit1 n
h₂ : bit0 m * (bit1 n / bit0 m) + bit1 n % bit0 m = bit1 n
⊢ bit1 n % bit0 m = bit1 (n % m)

tactic: exact add_left_cancel (h₂.trans h₁.symm)
state_before: m n : ℕ
h₁ : bit0 m * (n / m) + bit1 (n % m) = bit1 n
h₂ : bit0 m * (n / m) + bit1 n % bit0 m = bit1 n
⊢ bit1 n % bit0 m = bit1 (n % m)
Theorem: EuclideanGeometry.Sphere.secondInter_eq_self_iff
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

tactic: refine' ⟨fun hp => _, fun hp => _⟩
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ secondInter s p v = p ↔ inner v (p -ᵥ s.center) = 0

tactic: by_cases hv : v = 0
state_before: case refine'_1
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hp : secondInter s p v = p
⊢ inner v (p -ᵥ s.center) = 0

tactic: rwa [Sphere.secondInter, eq_comm, eq_vadd_iff_vsub_eq, vsub_self, eq_comm, smul_eq_zero,
  or_iff_left hv, div_eq_zero_iff, inner_self_eq_zero, or_iff_left hv, mul_eq_zero,
  or_iff_right (by norm_num : (-2 : ℝ) ≠ 0)] at hp
state_before: case neg
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hp : secondInter s p v = p
hv : ¬v = 0
⊢ inner v (p -ᵥ s.center) = 0

tactic: simp [hv]
state_before: case pos
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hp : secondInter s p v = p
hv : v = 0
⊢ inner v (p -ᵥ s.center) = 0

tactic: norm_num
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hp : -2 = 0 ∨ inner v (p -ᵥ s.center) = 0
hv : ¬v = 0
⊢ -2 ≠ 0

tactic: rw [Sphere.secondInter, hp, MulZeroClass.mul_zero, zero_div, zero_smul, zero_vadd]
state_before: case refine'_2
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hp : inner v (p -ᵥ s.center) = 0
⊢ secondInter s p v = p
Theorem: PowerSeries.coeff_mul_X_pow'
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: split_ifs with h
state_before: R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
⊢ ↑(coeff R d) (p * X ^ n) = if n ≤ d then ↑(coeff R (d - n)) p else 0

tactic: rw [← tsub_add_cancel_of_le h, coeff_mul_X_pow, add_tsub_cancel_right]
state_before: case inl
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
h : n ≤ d
⊢ ↑(coeff R d) (p * X ^ n) = ↑(coeff R (d - n)) p

tactic: refine' (coeff_mul _ _ _).trans (Finset.sum_eq_zero fun x hx => _)
state_before: case inr
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
h : ¬n ≤ d
⊢ ↑(coeff R d) (p * X ^ n) = 0

tactic: rw [coeff_X_pow, if_neg, MulZeroClass.mul_zero]
state_before: case inr
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
h : ¬n ≤ d
x : ℕ × ℕ
hx : x ∈ Finset.Nat.antidiagonal d
⊢ ↑(coeff R x.fst) p * ↑(coeff R x.snd) (X ^ n) = 0

tactic: exact ((le_of_add_le_right (Finset.Nat.mem_antidiagonal.mp hx).le).trans_lt <| not_le.mp h).ne
state_before: case inr.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
h : ¬n ≤ d
x : ℕ × ℕ
hx : x ∈ Finset.Nat.antidiagonal d
⊢ ¬x.snd = n
Theorem: skewAdjoint.bit0_mem
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: rw [mem_iff, star_bit0, mem_iff.mp hx, bit0, bit0, neg_add]
state_before: R : Type u_1
A : Type ?u.107570
inst✝¹ : AddCommGroup R
inst✝ : StarAddMonoid R
x : R
hx : x ∈ skewAdjoint R
⊢ bit0 x ∈ skewAdjoint R
Theorem: Set.sep_eq_empty_iff_mem_false
File: Mathlib/Data/Set/Basic.lean

tactic: simp_rw [ext_iff, mem_sep_iff, mem_empty_iff_false, iff_false_iff, not_and]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
p q : α → Prop
x : α
⊢ {x | x ∈ s ∧ p x} = ∅ ↔ ∀ (x : α), x ∈ s → ¬p x
Theorem: Set.toFinset_image
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.94256
s✝ t : Set α
inst✝² : DecidableEq β
f : α → β
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑(f '' s)
⊢ ↑(toFinset (f '' s)) = ↑(Finset.image f (toFinset s))