tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.boxProd_neighborFinset
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: letI : Fintype ((G □ H).neighborSet x) := SimpleGraph.boxProdFintypeNeighborSet _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.86875
G : SimpleGraph α
H : SimpleGraph β
x : α × β
inst✝² : Fintype ↑(neighborSet G x.fst)
inst✝¹ : Fintype ↑(neighborSet H x.snd)
inst✝ : Fintype ↑(neighborSet (G □ H) x)
⊢ neighborFinset (G □ H) x =
    Finset.disjUnion (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd)
      (_ : Disjoint (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd))

tactic: convert_to (G □ H).neighborFinset x = _ using 2
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.86875
G : SimpleGraph α
H : SimpleGraph β
x : α × β
inst✝² : Fintype ↑(neighborSet G x.fst)
inst✝¹ : Fintype ↑(neighborSet H x.snd)
inst✝ : Fintype ↑(neighborSet (G □ H) x)
this : Fintype ↑(neighborSet (G □ H) x) := boxProdFintypeNeighborSet x
⊢ neighborFinset (G □ H) x =
    Finset.disjUnion (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd)
      (_ : Disjoint (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd))

tactic: exact Eq.trans (Finset.map_map _ _ _) Finset.attach_map_val
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.86875
G : SimpleGraph α
H : SimpleGraph β
x : α × β
inst✝² : Fintype ↑(neighborSet G x.fst)
inst✝¹ : Fintype ↑(neighborSet H x.snd)
inst✝ : Fintype ↑(neighborSet (G □ H) x)
this : Fintype ↑(neighborSet (G □ H) x) := boxProdFintypeNeighborSet x
⊢ neighborFinset (G □ H) x =
    Finset.disjUnion (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd)
      (_ : Disjoint (neighborFinset G x.fst ×ˢ {x.snd}) ({x.fst} ×ˢ neighborFinset H x.snd))
Theorem: integral_inv_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [← one_div]
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, (1 + x ^ 2)⁻¹) = arctan b - arctan a

tactic: refine' integral_deriv_eq_sub' _ _ _ (continuous_const.div _ fun x => _).continuousOn
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, 1 / (1 + x ^ 2)) = arctan b - arctan a

tactic: norm_num
state_before: case refine'_1
a b : ℝ
n : ℕ
⊢ deriv arctan = fun x => 1 / (1 + x ^ 2)

tactic: exact fun _ _ => differentiableAt_arctan _
state_before: case refine'_2
a b : ℝ
n : ℕ
⊢ ∀ (x : ℝ), x ∈ [[a, b]] → DifferentiableAt ℝ arctan x

tactic: continuity
state_before: case refine'_3
a b : ℝ
n : ℕ
⊢ Continuous fun x => 1 + x ^ 2

tactic: nlinarith
state_before: case refine'_4
a b : ℝ
n : ℕ
x : ℝ
⊢ 1 + x ^ 2 ≠ 0
Theorem: Polynomial.map_mod_divByMonic
File: Mathlib/Data/Polynomial/Div.lean

tactic: nontriviality S
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q

tactic: haveI : Nontrivial R := f.domain_nontrivial
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q

tactic: have : map f p /ₘ map f q = map f (p /ₘ q) ∧ map f p %ₘ map f q = map f (p %ₘ q) :=
  div_modByMonic_unique ((p /ₘ q).map f) _ (hq.map f)
    ⟨Eq.symm <| by rw [← Polynomial.map_mul, ← Polynomial.map_add, modByMonic_add_div _ hq],
      calc
        _ ≤ degree (p %ₘ q) := degree_map_le _ _
        _ < degree q := (degree_modByMonic_lt _ hq)
        _ = _ :=
          Eq.symm <|
            degree_map_eq_of_leadingCoeff_ne_zero _
              (by rw [Monic.def.1 hq, f.map_one]; exact one_ne_zero)⟩
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
this : Nontrivial R
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q

tactic: exact ⟨this.1.symm, this.2.symm⟩
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
this✝ : Nontrivial R
this : map f p /ₘ map f q = map f (p /ₘ q) ∧ map f p %ₘ map f q = map f (p %ₘ q)
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q

tactic: rw [← Polynomial.map_mul, ← Polynomial.map_add, modByMonic_add_div _ hq]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
this : Nontrivial R
⊢ map f p = map f (p %ₘ q) + map f q * map f (p /ₘ q)

tactic: rw [Monic.def.1 hq, f.map_one]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
this : Nontrivial R
⊢ ↑f (leadingCoeff q) ≠ 0

tactic: exact one_ne_zero
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hq : Monic q
✝ : Nontrivial S
this : Nontrivial R
⊢ 1 ≠ 0
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_snd_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ snd ≫ snd = snd

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (Iso.mk (lift (snd ≫ fst) (snd ≫ snd) (_ : (snd ≫ fst) ≫ i₁ = (snd ≫ snd) ≫ i₂))
          (lift (fst ≫ i₁ ≫ fst)
            (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
              (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd))
            (_ :
              (fst ≫ i₁ ≫ fst) ≫ diagonal f =
                map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
                    (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
                  map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
                    (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)))).inv ≫
      snd ≫ snd =
    snd
Theorem: Filter.tendsto_const_mul_atTop_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [inv_mul_cancel_left₀ hr.ne']
state_before: ι : Type ?u.215087
ι' : Type ?u.215090
α : Type u_1
β : Type u_2
γ : Type ?u.215099
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
hr : 0 < r
h : Tendsto f l atTop
⊢ Tendsto (fun x => r⁻¹ * (r * f x)) l atTop
Theorem: ENNReal.ofReal_eq_zero
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [ENNReal.ofReal]
state_before: α : Type ?u.807876
β : Type ?u.807879
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ
⊢ ENNReal.ofReal p = 0 ↔ p ≤ 0
Theorem: List.tail_suffix
File: Mathlib/Data/List/Infix.lean

tactic: rw [← drop_one]
state_before: α : Type u_1
β : Type ?u.2600
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ tail l <:+ l

tactic: apply drop_suffix
state_before: α : Type u_1
β : Type ?u.2600
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ drop 1 l <:+ l
Theorem: NNReal.hasSum_coe
File: Mathlib/Topology/Instances/NNReal.lean

tactic: simp only [HasSum, ← coe_sum, tendsto_coe]
state_before: α : Type u_1
f : α → ℝ≥0
r : ℝ≥0
⊢ HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r
Theorem: List.nodup_enum_map_fst
File: Mathlib/Data/List/Sigma.lean

tactic: simp [List.nodup_range]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
l : List α
⊢ Nodup (map Prod.fst (enum l))
Theorem: CategoryTheory.Limits.pullbackAssoc_inv_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [Iso.inv_comp_eq, pullbackAssoc_hom_snd_snd]
state_before: C : Type u
inst✝⁷ : Category C
D : Type u₂
inst✝⁶ : Category D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.snd = pullback.snd ≫ pullback.snd
Theorem: CancelDenoms.div_subst
File: Mathlib/Tactic/CancelDenoms.lean

tactic: rw [← h3, mul_assoc, mul_div_left_comm, h2, ← mul_assoc, h1, mul_comm, one_mul]
state_before: α : Type u_1
inst✝ : Field α
n1 n2 k e1 e2 t1 : α
h1 : n1 * e1 = t1
h2 : n2 / e2 = 1
h3 : n1 * n2 = k
⊢ k * (e1 / e2) = t1
Theorem: symmDiff_eq_left
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_bot]
state_before: ι : Type ?u.76166
α : Type u_1
β : Type ?u.76172
π : ι → Type ?u.76177
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b = a ↔ a ∆ b = a ∆ ⊥

tactic: rw [symmDiff_right_inj]
state_before: ι : Type ?u.76166
α : Type u_1
β : Type ?u.76172
π : ι → Type ?u.76177
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b = a ∆ ⊥ ↔ b = ⊥
Theorem: PGame.Subsequent.mk_right'
File: Mathlib/SetTheory/Game/PGame.lean

tactic: pgame_wf_tac
state_before: xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
j : RightMoves (mk xl xr xL xR)
⊢ Subsequent (xR j) (mk xl xr xL xR)
Theorem: LinearLocallyFiniteOrder.le_of_lt_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [lt_isGLB_iff (succFn_spec i)] at hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : j < succFn i
⊢ j ≤ i

tactic: obtain ⟨k, hk_lb, hk⟩ := hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : ∃ c, c ∈ lowerBounds (Set.Ioi i) ∧ j < c
⊢ j ≤ i

tactic: rw [mem_lowerBounds] at hk_lb
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : k ∈ lowerBounds (Set.Ioi i)
hk : j < k
⊢ j ≤ i

tactic: exact not_lt.mp fun hi_lt_j ↦ not_le.mpr hk (hk_lb j hi_lt_j)
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : ∀ (x : ι), x ∈ Set.Ioi i → k ≤ x
hk : j < k
⊢ j ≤ i
Theorem: LocalHomeomorph.continuousAt_extend_symm
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [f.extend_source]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.144430
M' : Type ?u.144433
H' : Type ?u.144436
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
⊢ x ∈ (extend f I).source
Theorem: Complex.sin_sub_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sub_eq_add_neg, sin_add]
state_before: x : ℂ
⊢ sin (x - ↑π / 2) = -cos x
Theorem: Set.image_neg_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Ioc a b = Ico (-b) (-a)
Theorem: Finset.map_comm
File: Mathlib/Data/Finset/Image.lean

tactic: simp_rw [map_map, Embedding.trans, Function.comp, h_comm]
state_before: α : Type u_4
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
β' : Type u_1
f : β ↪ γ
g : α ↪ β
f' : α ↪ β'
g' : β' ↪ γ
h_comm : ∀ (a : α), ↑f (↑g a) = ↑g' (↑f' a)
⊢ map f (map g s) = map g' (map f' s)
Theorem: WithSeminorms.separating_iff_T1
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: refine' ⟨WithSeminorms.T1_of_separating hp, _⟩
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.228889
𝕝 : Type ?u.228892
𝕝₂ : Type ?u.228895
E : Type u_2
F : Type ?u.228901
G : Type ?u.228904
ι : Type u_3
ι' : Type ?u.228910
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
⊢ (∀ (x : E), x ≠ 0 → ∃ i, ↑(p i) x ≠ 0) ↔ T1Space E

tactic: intro
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.228889
𝕝 : Type ?u.228892
𝕝₂ : Type ?u.228895
E : Type u_2
F : Type ?u.228901
G : Type ?u.228904
ι : Type u_3
ι' : Type ?u.228910
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
⊢ T1Space E → ∀ (x : E), x ≠ 0 → ∃ i, ↑(p i) x ≠ 0

tactic: exact WithSeminorms.separating_of_T1 hp
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.228889
𝕝 : Type ?u.228892
𝕝₂ : Type ?u.228895
E : Type u_2
F : Type ?u.228901
G : Type ?u.228904
ι : Type u_3
ι' : Type ?u.228910
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
a✝ : T1Space E
⊢ ∀ (x : E), x ≠ 0 → ∃ i, ↑(p i) x ≠ 0
Theorem: Set.ncard_le_ncard_of_injOn
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' s.finite_or_infinite with h h
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard s ≤ ncard t

tactic: convert Nat.zero_le _
state_before: case inr
α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Infinite s
⊢ ncard s ≤ ncard t

tactic: rw [h.ncard]
state_before: case h.e'_3
α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Infinite s
⊢ ncard s = 0

tactic: haveI := h.to_subtype
state_before: case inl
α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
⊢ ncard s ≤ ncard t

tactic: rw [ncard_eq_toFinset_card _ ht, ncard_eq_toFinset_card _ (toFinite s)]
state_before: case inl
α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
this : Finite ↑s
⊢ ncard s ≤ ncard t

tactic: exact Finset.card_le_card_of_inj_on f (by simpa) (by simpa)
state_before: case inl
α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
this : Finite ↑s
⊢ Finset.card (Finite.toFinset (_ : Set.Finite s)) ≤ Finset.card (Finite.toFinset ht)

tactic: simpa
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
this : Finite ↑s
⊢ ∀ (a : α), a ∈ Finite.toFinset (_ : Set.Finite s) → f a ∈ Finite.toFinset ht

tactic: simpa
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
f_inj : InjOn f s
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
this : Finite ↑s
⊢ ∀ (a₁ : α),
    a₁ ∈ Finite.toFinset (_ : Set.Finite s) →
      ∀ (a₂ : α), a₂ ∈ Finite.toFinset (_ : Set.Finite s) → f a₁ = f a₂ → a₁ = a₂
Theorem: Rat.not_secondCountableTopology_opc
File: Mathlib/Topology/Instances/RatLemmas.lean

tactic: intro
state_before: p q : ℚ
s t : Set ℚ
⊢ ¬SecondCountableTopology ℚ∞

tactic: exact not_firstCountableTopology_opc inferInstance
state_before: p q : ℚ
s t : Set ℚ
a✝ : SecondCountableTopology ℚ∞
⊢ False
Theorem: Int.even_add
File: Mathlib/Data/Int/Parity.lean

tactic: cases' emod_two_eq_zero_or_one m with h₁ h₁ <;>
cases' emod_two_eq_zero_or_one n with h₂ h₂ <;>
simp [even_iff, h₁, h₂, Int.add_emod]
state_before: m n : ℤ
⊢ Even (m + n) ↔ (Even m ↔ Even n)
Theorem: LocalEquiv.IsImage.symm_eq_on_of_inter_eq_of_eqOn
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [← h.image_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30876
δ : Type ?u.30879
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
⊢ EqOn (↑(LocalEquiv.symm e)) (↑(LocalEquiv.symm e')) (e.target ∩ t)

tactic: rintro y ⟨x, hx, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30876
δ : Type ?u.30879
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
⊢ EqOn (↑(LocalEquiv.symm e)) (↑(LocalEquiv.symm e')) (↑e '' (e.source ∩ s))

tactic: have hx' := hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.30876
δ : Type ?u.30879
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x✝ : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
x : α
hx : x ∈ e.source ∩ s
⊢ ↑(LocalEquiv.symm e) (↑e x) = ↑(LocalEquiv.symm e') (↑e x)

tactic: rw [hs] at hx'
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.30876
δ : Type ?u.30879
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x✝ : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
x : α
hx hx' : x ∈ e.source ∩ s
⊢ ↑(LocalEquiv.symm e) (↑e x) = ↑(LocalEquiv.symm e') (↑e x)

tactic: rw [e.left_inv hx.1, heq hx, e'.left_inv hx'.1]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.30876
δ : Type ?u.30879
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x✝ : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
x : α
hx : x ∈ e.source ∩ s
hx' : x ∈ e'.source ∩ s
⊢ ↑(LocalEquiv.symm e) (↑e x) = ↑(LocalEquiv.symm e') (↑e x)
Theorem: Complex.sin_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
⊢ sin (3 * x) = 3 * sin x - 4 * sin x ^ 3

tactic: rw [← h1, sin_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sin (3 * x) = 3 * sin x - 4 * sin x ^ 3

tactic: simp only [cos_two_mul, sin_two_mul, cos_sq']
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sin x * cos (2 * x) + cos x * sin (2 * x) = 3 * sin x - 4 * sin x ^ 3

tactic: have h2 : cos x * (2 * sin x * cos x) = 2 * sin x * cos x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sin x * (2 * (1 - sin x ^ 2) - 1) + cos x * (2 * sin x * cos x) = 3 * sin x - 4 * sin x ^ 3

tactic: rw [h2, cos_sq']
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : cos x * (2 * sin x * cos x) = 2 * sin x * cos x ^ 2
⊢ sin x * (2 * (1 - sin x ^ 2) - 1) + cos x * (2 * sin x * cos x) = 3 * sin x - 4 * sin x ^ 3

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : cos x * (2 * sin x * cos x) = 2 * sin x * cos x ^ 2
⊢ sin x * (2 * (1 - sin x ^ 2) - 1) + 2 * sin x * (1 - sin x ^ 2) = 3 * sin x - 4 * sin x ^ 3

tactic: ring
state_before: x y : ℂ
⊢ x + 2 * x = 3 * x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * (2 * sin x * cos x) = 2 * sin x * cos x ^ 2
Theorem: Finset.eraseNone_eq_biUnion
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.8977
inst✝ : DecidableEq α
s : Finset (Option α)
⊢ ↑eraseNone s = Finset.biUnion s Option.toFinset

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.8977
inst✝ : DecidableEq α
s : Finset (Option α)
a✝ : α
⊢ a✝ ∈ ↑eraseNone s ↔ a✝ ∈ Finset.biUnion s Option.toFinset
Theorem: Cycle.induction_on
File: Mathlib/Data/List/Cycle.lean

tactic: refine List.recOn l ?_ ?_ <;> simp
state_before: α : Type u_1
C : Cycle α → Prop
s : Cycle α
H0 : C nil
HI : ∀ (a : α) (l : List α), C ↑l → C ↑(a :: l)
l : List α
⊢ C (Quotient.mk'' l)

tactic: assumption'
state_before: case refine_1
α : Type u_1
C : Cycle α → Prop
s : Cycle α
H0 : C nil
HI : ∀ (a : α) (l : List α), C ↑l → C ↑(a :: l)
l : List α
⊢ C nil

case refine_2
α : Type u_1
C : Cycle α → Prop
s : Cycle α
H0 : C nil
HI : ∀ (a : α) (l : List α), C ↑l → C ↑(a :: l)
l : List α
⊢ ∀ (head : α) (tail : List α), C ↑tail → C ↑(head :: tail)
Theorem: IsUnit.isSMulRegular
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rcases ua with ⟨a, rfl⟩
state_before: R : Type u_1
S : Type ?u.36377
M : Type u_2
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ua : IsUnit a
⊢ IsSMulRegular M a

tactic: exact a.isSMulRegular M
state_before: case intro
R : Type u_1
S : Type ?u.36377
M : Type u_2
b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a : Rˣ
⊢ IsSMulRegular M ↑a
Theorem: IsLocalizedModule.mk'_cancel'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [Submonoid.smul_def, ← mk'_smul, ← Submonoid.smul_def, mk'_cancel]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.834666
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
⊢ s • mk' f m s = ↑f m
Theorem: Acc.ndrecOn_eq_ndrecOnC
File: Std/WF.lean

tactic: funext α r motive intro a t
state_before: ⊢ @ndrecOn = @Acc.ndrecOnC

tactic: rw [Acc.ndrecOn, rec_eq_recC, Acc.ndrecOnC]
state_before: case h.h.h.h.h.h
α : Sort u_1
r : α → α → Prop
motive : α → Sort u_2
intro : α
a : Acc r intro
t : (x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → motive y) → motive x
⊢ ndrecOn a t = Acc.ndrecOnC a t
Theorem: one_zpow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [zpow_ofNat, one_pow]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a b : α
n : ℕ
⊢ 1 ^ ↑n = 1

tactic: rw [zpow_negSucc, one_pow, inv_one]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a b : α
n : ℕ
⊢ 1 ^ Int.negSucc n = 1
Theorem: isComplete_iff_ultrafilter
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine' ⟨fun h l => h l, fun H => isComplete_iff_clusterPt.2 fun l hl hls => _⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ IsComplete s ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x

tactic: haveI := hl.1
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x
l : Filter α
hl : Cauchy l
hls : l ≤ 𝓟 s
⊢ ∃ x, x ∈ s ∧ ClusterPt x l

tactic: rcases H (Ultrafilter.of l) hl.ultrafilter_of ((Ultrafilter.of_le l).trans hls) with ⟨x, hxs, hxl⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x
l : Filter α
hl : Cauchy l
hls : l ≤ 𝓟 s
this : NeBot l
⊢ ∃ x, x ∈ s ∧ ClusterPt x l

tactic: exact ⟨x, hxs, (ClusterPt.of_le_nhds hxl).mono (Ultrafilter.of_le l)⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x
l : Filter α
hl : Cauchy l
hls : l ≤ 𝓟 s
this : NeBot l
x : α
hxs : x ∈ s
hxl : ↑(Ultrafilter.of l) ≤ 𝓝 x
⊢ ∃ x, x ∈ s ∧ ClusterPt x l
Theorem: IntermediateField.induction_on_adjoin_fg
File: Mathlib/FieldTheory/Adjoin.lean

tactic: obtain ⟨S, rfl⟩ := hK
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
P : IntermediateField F E → Prop
base : P ⊥
ih : ∀ (K : IntermediateField F E) (x : E), P K → P (restrictScalars F { x // x ∈ K }⟮x⟯)
K : IntermediateField F E
hK : FG K
⊢ P K

tactic: exact induction_on_adjoin_finset S P base fun K x _ hK => ih K x hK
state_before: case intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
P : IntermediateField F E → Prop
base : P ⊥
ih : ∀ (K : IntermediateField F E) (x : E), P K → P (restrictScalars F { x // x ∈ K }⟮x⟯)
S : Finset E
⊢ P (adjoin F ↑S)
Theorem: Mathlib.Tactic.Group.zpow_trick_one'
File: Mathlib/Tactic/Group.lean

tactic: rw [mul_assoc, mul_zpow_self]
state_before: G : Type u_1
inst✝ : Group G
a b : G
n : ℤ
⊢ a * b ^ n * b = a * b ^ (n + 1)