tasksource/leandojo huggingface dataset:
Theorem: HasFPowerSeriesAt.eq_formalMultilinearSeries
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simpa only [sub_self] using h₁.sub h₂
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1145337
G : Type ?u.1145340
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p₁ p₂ : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
x : 𝕜
h₁ : HasFPowerSeriesAt f p₁ x
h₂ : HasFPowerSeriesAt f p₂ x
⊢ HasFPowerSeriesAt 0 (p₁ - p₂) (?m.1149252 h₁ h₂)
Theorem: Fin.succ_zero_eq_one
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
inst✝ : NeZero n
⊢ succ 0 = 1

tactic: exact (NeZero.ne 0 rfl).elim
state_before: case zero
m : ℕ
inst✝ : NeZero zero
⊢ succ 0 = 1

tactic: rfl
state_before: case succ
m n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
⊢ succ 0 = 1
Theorem: Filter.tendstoIxxClass_principal
File: Mathlib/Order/Filter/Interval.lean

tactic: simp only [smallSets_principal, prod_principal_principal, tendsto_principal_principal,
  forall_prod_set, mem_powerset_iff, mem_principal]
state_before: α : Type u_1
β : Type ?u.5916
inst✝ : Preorder α
s t : Set α
Ixx : α → α → Set α
⊢ Tendsto (fun p => Ixx p.fst p.snd) (𝓟 s ×ˢ 𝓟 s) (smallSets (𝓟 t)) ↔ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → Ixx x y ⊆ t
Theorem: Finsupp.coe_update
File: Mathlib/Data/Finsupp/Defs.lean

tactic: delta update Function.update
state_before: α : Type u_1
β : Type ?u.147517
γ : Type ?u.147520
ι : Type ?u.147523
M : Type u_2
M' : Type ?u.147529
N : Type ?u.147532
P : Type ?u.147535
G : Type ?u.147538
H : Type ?u.147541
R : Type ?u.147544
S : Type ?u.147547
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ↑(update f a b) = Function.update (↑f) a b

tactic: ext
state_before: α : Type u_1
β : Type ?u.147517
γ : Type ?u.147520
ι : Type ?u.147523
M : Type u_2
M' : Type ?u.147529
N : Type ?u.147532
P : Type ?u.147535
G : Type ?u.147538
H : Type ?u.147541
R : Type ?u.147544
S : Type ?u.147547
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ↑{ support := if b = 0 then erase f.support a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then (_ : a = a_1) ▸ b else ↑f a_1,
        mem_support_toFun :=
          (_ :
            ∀ (i : α),
              (i ∈ if b = 0 then erase f.support a else insert a f.support) ↔ Function.update (↑f) a b i ≠ 0) } =
    fun a_1 => if h : a_1 = a then (_ : a = a_1) ▸ b else ↑f a_1

tactic: dsimp
state_before: case h
α : Type u_1
β : Type ?u.147517
γ : Type ?u.147520
ι : Type ?u.147523
M : Type u_2
M' : Type ?u.147529
N : Type ?u.147532
P : Type ?u.147535
G : Type ?u.147538
H : Type ?u.147541
R : Type ?u.147544
S : Type ?u.147547
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ ↑{ support := if b = 0 then erase f.support a else insert a f.support,
          toFun := fun a_1 => if h : a_1 = a then (_ : a = a_1) ▸ b else ↑f a_1,
          mem_support_toFun :=
            (_ :
              ∀ (i : α),
                (i ∈ if b = 0 then erase f.support a else insert a f.support) ↔ Function.update (↑f) a b i ≠ 0) }
      x✝ =
    if h : x✝ = a then (_ : a = x✝) ▸ b else ↑f x✝

tactic: split_ifs <;> simp
state_before: case h
α : Type u_1
β : Type ?u.147517
γ : Type ?u.147520
ι : Type ?u.147523
M : Type u_2
M' : Type ?u.147529
N : Type ?u.147532
P : Type ?u.147535
G : Type ?u.147538
H : Type ?u.147541
R : Type ?u.147544
S : Type ?u.147547
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ (if h : x✝ = a then (_ : a = x✝) ▸ b else ↑f x✝) = if h : x✝ = a then (_ : a = x✝) ▸ b else ↑f x✝
Theorem: Real.tendsto_sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: convert continuous_sin.continuousWithinAt.tendsto
state_before: ⊢ Tendsto sin (𝓝[Iio (π / 2)] (π / 2)) (𝓝 1)

tactic: simp
state_before: case h.e'_5.h.e'_3

⊢ 1 = sin (π / 2)
Theorem: StarSubalgebra.toSubalgebra_injective
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: rw [← mem_toSubalgebra, ← mem_toSubalgebra, h]
state_before: F : Type ?u.43327
R : Type u_2
A : Type u_1
B : Type ?u.43336
C : Type ?u.43339
inst✝¹³ : CommSemiring R
inst✝¹² : StarRing R
inst✝¹¹ : Semiring A
inst✝¹⁰ : StarRing A
inst✝⁹ : Algebra R A
inst✝⁸ : StarModule R A
inst✝⁷ : Semiring B
inst✝⁶ : StarRing B
inst✝⁵ : Algebra R B
inst✝⁴ : StarModule R B
inst✝³ : Semiring C
inst✝² : StarRing C
inst✝¹ : Algebra R C
inst✝ : StarModule R C
S T : StarSubalgebra R A
h : S.toSubalgebra = T.toSubalgebra
x : A
⊢ x ∈ S ↔ x ∈ T
Theorem: ENNReal.ofReal_nsmul
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [nsmul_eq_mul, ← ofReal_coe_nat n, ← ofReal_mul n.cast_nonneg]
state_before: α : Type ?u.815667
β : Type ?u.815670
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ
n : ℕ
⊢ ENNReal.ofReal (n • x) = n • ENNReal.ofReal x
Theorem: Dfinsupp.Lex.wellFounded
File: Mathlib/Data/Dfinsupp/WellFounded.lean

tactic: classical exact Lex.acc hbot hs x fun i _ => hr.apply i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0
hs : ∀ (i : ι), WellFounded (s i)
hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1)
x : Π₀ (i : ι), α i
⊢ Acc (Dfinsupp.Lex r s) x

tactic: exact Lex.acc hbot hs x fun i _ => hr.apply i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0
hs : ∀ (i : ι), WellFounded (s i)
hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1)
x : Π₀ (i : ι), α i
⊢ Acc (Dfinsupp.Lex r s) x
Theorem: Option.join_eq_some
File: Std/Data/Option/Lemmas.lean

tactic: simp
state_before: α✝ : Type u_1
a : α✝
x : Option (Option α✝)
⊢ join x = some a ↔ x = some (some a)
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: simp [← Iso.eq_inv_comp]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).hom ≫ prod.fst = pullback.fst
Theorem: HasFDerivWithinAt.mul_const
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: convert hc.mul_const' d
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.903195
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.903290
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.903385
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.905520
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivWithinAt c c' s x
d : 𝔸'
⊢ HasFDerivWithinAt (fun y => c y * d) (d • c') s x

tactic: ext z
state_before: case h.e'_10
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.903195
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.903290
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.903385
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.905520
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivWithinAt c c' s x
d : 𝔸'
⊢ d • c' = smulRight c' d

tactic: apply mul_comm
state_before: case h.e'_10.h
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.903195
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.903290
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.903385
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.905520
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivWithinAt c c' s x
d : 𝔸'
z : E
⊢ ↑(d • c') z = ↑(smulRight c' d) z
Theorem: ENNReal.hasSum_coe
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [HasSum, ← coe_finset_sum, tendsto_coe]
state_before: α : Type u_1
β : Type ?u.229498
γ : Type ?u.229501
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : α → ℝ≥0
r : ℝ≥0
⊢ HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r
Theorem: MeasurableSpace.DynkinSystem.generate_inter
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rwa [inter_comm]
state_before: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
t₁ t₂ : Set α
ht₁ : Has (generate s) t₁
ht₂ : Has (generate s) t₂
s₁ : Set α
hs₁ : s₁ ∈ s
this✝¹ : Has (generate s) s₁
this✝ : generate s ≤ restrictOn (generate s) this✝¹
this : Has (generate s) (t₂ ∩ s₁)
⊢ Has (generate s) (s₁ ∩ t₂)
Theorem: Nat.minSqFac_dvd
File: Mathlib/Data/Nat/Squarefree.lean

tactic: have := minSqFac_has_prop n
state_before: n d : ℕ
h : minSqFac n = some d
⊢ d * d ∣ n

tactic: rw [h] at this
state_before: n d : ℕ
h : minSqFac n = some d
this : MinSqFacProp n (minSqFac n)
⊢ d * d ∣ n

tactic: exact this.2.1
state_before: n d : ℕ
h : minSqFac n = some d
this : MinSqFacProp n (some d)
⊢ d * d ∣ n
Theorem: PNat.Coprime.gcd_mul_left_cancel_right
File: Mathlib/Data/PNat/Prime.lean

tactic: intro h
state_before: m n k : ℕ+
⊢ Coprime k m → gcd m (k * n) = gcd m n

tactic: iterate 2 rw [gcd_comm]; symm;
state_before: m n k : ℕ+
h : Coprime k m
⊢ gcd m (k * n) = gcd m n

tactic: apply Coprime.gcd_mul_left_cancel _ h
state_before: m n k : ℕ+
h : Coprime k m
⊢ gcd (k * n) m = gcd n m

tactic: rw [gcd_comm]
state_before: m n k : ℕ+
h : Coprime k m
⊢ gcd m n = gcd (k * n) m

tactic: symm
state_before: m n k : ℕ+
h : Coprime k m
⊢ gcd n m = gcd (k * n) m
Theorem: SimpleGraph.isNClique_bot_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: rw [isNClique_iff, isClique_bot_iff]
state_before: α : Type u_1
G H : SimpleGraph α
n : ℕ
s : Finset α
⊢ IsNClique ⊥ n s ↔ n ≤ 1 ∧ Finset.card s = n

tactic: refine' and_congr_left _
state_before: α : Type u_1
G H : SimpleGraph α
n : ℕ
s : Finset α
⊢ Set.Subsingleton ↑s ∧ Finset.card s = n ↔ n ≤ 1 ∧ Finset.card s = n

tactic: rintro rfl
state_before: α : Type u_1
G H : SimpleGraph α
n : ℕ
s : Finset α
⊢ Finset.card s = n → (Set.Subsingleton ↑s ↔ n ≤ 1)

tactic: exact card_le_one.symm
state_before: α : Type u_1
G H : SimpleGraph α
s : Finset α
⊢ Set.Subsingleton ↑s ↔ Finset.card s ≤ 1
Theorem: Finset.prod_nat_mod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.prod, Multiset.map_map]
state_before: ι : Type ?u.876983
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℕ
f : α → ℕ
⊢ Multiset.prod (Multiset.map (fun x => x % n) (Multiset.map (fun i => f i) s.val)) % n = (∏ i in s, f i % n) % n

tactic: rfl
state_before: ι : Type ?u.876983
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℕ
f : α → ℕ
⊢ Multiset.prod (Multiset.map ((fun x => x % n) ∘ fun i => f i) s.val) % n =
    Multiset.prod (Multiset.map (fun i => f i % n) s.val) % n
Theorem: Real.arccos_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, ← sin_pi_div_two_sub, arcsin_sin] <;> simp [sub_eq_add_neg] <;> linarith
state_before: x : ℝ
hx₁ : 0 ≤ x
hx₂ : x ≤ π
⊢ arccos (cos x) = x
Theorem: Finset.inter_filter
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, filter_inter, inter_comm]
state_before: α : Type u_1
β : Type ?u.378630
γ : Type ?u.378633
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s t : Finset α
⊢ s ∩ filter p t = filter p (s ∩ t)
Theorem: Set.piecewise_insert_self
File: Mathlib/Data/Set/Function.lean

tactic: simp [piecewise]
state_before: α : Type u_1
β : Type ?u.72650
γ : Type ?u.72653
ι : Sort ?u.72656
π : α → Type ?u.72661
δ : α → Sort u_2
s : Set α
f g : (i : α) → δ i
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ piecewise (insert j s) f g j = f j
Theorem: Set.ncard_image_of_injOn
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' s.finite_or_infinite with h h
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
H : InjOn f s
⊢ ncard (f '' s) = ncard s

tactic: rw [h.ncard, ((infinite_image_iff H).mpr h).ncard]
state_before: case inr
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
H : InjOn f s
h : Set.Infinite s
⊢ ncard (f '' s) = ncard s

tactic: haveI := @Fintype.ofFinite s h.to_subtype
state_before: case inl
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
H : InjOn f s
h : Set.Finite s
⊢ ncard (f '' s) = ncard s

tactic: haveI := @Fintype.ofFinite _ (h.image f).to_subtype
state_before: case inl
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
H : InjOn f s
h : Set.Finite s
this : Fintype ↑s
⊢ ncard (f '' s) = ncard s

tactic: convert card_image_of_inj_on H <;> simp [ncard_def]
state_before: case inl
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
H : InjOn f s
h : Set.Finite s
this✝ : Fintype ↑s
this : Fintype ↑(f '' s)
⊢ ncard (f '' s) = ncard s
Theorem: List.countp_map
File: Mathlib/Data/List/Count.lean

tactic: rw [map_cons, countp_cons, countp_cons, countp_map p f l]
state_before: α : Type u_2
l✝ : List α
p✝ q : α → Bool
β : Type u_1
p : β → Bool
f : α → β
a : α
l : List α
⊢ countp p (map f (a :: l)) = countp (p ∘ f) (a :: l)

tactic: rfl
state_before: α : Type u_2
l✝ : List α
p✝ q : α → Bool
β : Type u_1
p : β → Bool
f : α → β
a : α
l : List α
⊢ (countp (p ∘ f) l + if p (f a) = true then 1 else 0) = countp (p ∘ f) l + if (p ∘ f) a = true then 1 else 0
Theorem: segment_eq_image₂
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [segment, image, Prod.exists, mem_setOf_eq, exists_prop, and_assoc]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.12738
G : Type ?u.12741
ι : Type ?u.12744
π : ι → Type ?u.12749
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
s : Set E
x✝ y✝ x y : E
⊢ [x-[𝕜]y] = (fun p => p.fst • x + p.snd • y) '' {p | 0 ≤ p.fst ∧ 0 ≤ p.snd ∧ p.fst + p.snd = 1}
Theorem: List.ofFn_congr
File: Mathlib/Data/List/OfFn.lean

tactic: subst h
state_before: α : Type u
m n : ℕ
h : m = n
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (↑(Fin.cast (_ : n = m)) i)

tactic: simp_rw [Fin.cast_refl, OrderIso.refl_apply]
state_before: α : Type u
m : ℕ
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (↑(Fin.cast (_ : m = m)) i)
Theorem: CategoryTheory.Limits.ConeMorphism.ext
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: cases f
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cone F
f g : c ⟶ c'
w : f.Hom = g.Hom
⊢ f = g

tactic: cases g
state_before: case mk
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cone F
g : c ⟶ c'
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), Hom✝ ≫ c'.π.app j = c.π.app j
w : (mk Hom✝).Hom = g.Hom
⊢ mk Hom✝ = g

tactic: congr
state_before: case mk.mk
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cone F
Hom✝¹ : c.pt ⟶ c'.pt
w✝¹ : ∀ (j : J), Hom✝¹ ≫ c'.π.app j = c.π.app j
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), Hom✝ ≫ c'.π.app j = c.π.app j
w : (mk Hom✝¹).Hom = (mk Hom✝).Hom
⊢ mk Hom✝¹ = mk Hom✝
Theorem: Set.preimage_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [preimage_iUnion]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.223969
ι : Sort u_3
ι' : Sort ?u.223975
ι₂ : Sort ?u.223978
κ : ι → Sort u_4
κ₁ : ι → Sort ?u.223988
κ₂ : ι → Sort ?u.223993
κ' : ι' → Sort ?u.223998
f : α → β
s : (i : ι) → κ i → Set β
⊢ (f ⁻¹' ⋃ (i : ι) (j : κ i), s i j) = ⋃ (i : ι) (j : κ i), f ⁻¹' s i j
Theorem: Fintype.card_range_le
File: Mathlib/Data/Fintype/Card.lean

tactic: simp
state_before: α✝ : Type ?u.16264
β✝ : Type ?u.16267
γ : Type ?u.16270
inst✝³ : Fintype α✝
inst✝² : Fintype β✝
α : Type u_1
β : Type u_2
f : α → β
inst✝¹ : Fintype α
inst✝ : Fintype ↑(Set.range f)
a : α
⊢ f a ∈ Set.range f

tactic: simpa using ha
state_before: α✝ : Type ?u.16264
β✝ : Type ?u.16267
γ : Type ?u.16270
inst✝³ : Fintype α✝
inst✝² : Fintype β✝
α : Type u_1
β : Type u_2
f : α → β
inst✝¹ : Fintype α
inst✝ : Fintype ↑(Set.range f)
x✝ : ↑(Set.range f)
val✝ : β
a : α
ha : f a = val✝
⊢ (fun a => { val := f a, property := (_ : f a ∈ Set.range f) }) a = { val := val✝, property := (_ : ∃ y, f y = val✝) }
Theorem: LinearMap.convexOn
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.179930
α : Type ?u.179933
β : Type u_3
ι : Type ?u.179939
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 β
f : E →ₗ[𝕜] β
s : Set E
hs : Convex 𝕜 s
x✝⁸ : E
x✝⁷ : x✝⁸ ∈ s
x✝⁶ : E
x✝⁵ : x✝⁶ ∈ s
x✝⁴ x✝³ : 𝕜
x✝² : 0 ≤ x✝⁴
x✝¹ : 0 ≤ x✝³
x✝ : x✝⁴ + x✝³ = 1
⊢ ↑f (x✝⁴ • x✝⁸ + x✝³ • x✝⁶) ≤ x✝⁴ • ↑f x✝⁸ + x✝³ • ↑f x✝⁶
Theorem: List.mem_inter
File: Mathlib/Data/List/Lattice.lean

tactic: erw [mem_filter]
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ a ∈ l₁ ∩ l₂ ↔ a ∈ l₁ ∧ a ∈ l₂

tactic: simp
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ a ∈ l₁ ∧ decide (a ∈ l₂) = true ↔ a ∈ l₁ ∧ a ∈ l₂
Theorem: OnePoint.ne_infty_iff_exists
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: induction x using OnePoint.rec <;> simp
state_before: X : Type u_1
x : OnePoint X
⊢ x ≠ ∞ ↔ ∃ y, ↑y = x
Theorem: SimpleGraph.Walk.snd_mem_support_of_mem_edges
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [Sym2.eq_swap] at he
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G v w
he : Quotient.mk (Sym2.Rel.setoid V) (t, u) ∈ edges p
⊢ u ∈ support p

tactic: exact p.fst_mem_support_of_mem_edges he
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G v w
he : Quotient.mk (Sym2.Rel.setoid V) (u, t) ∈ edges p
⊢ u ∈ support p
Theorem: EuclideanGeometry.Sphere.sbtw_secondInter
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

tactic: refine' ⟨Sphere.wbtw_secondInter hp hp'.le, _, _⟩
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' : P
hp : p ∈ s
hp' : dist p' s.center < s.radius
⊢ Sbtw ℝ p p' (secondInter s p (p' -ᵥ p))

tactic: rintro rfl
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' : P
hp : p ∈ s
hp' : dist p' s.center < s.radius
⊢ p' ≠ p

tactic: rw [mem_sphere] at hp
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
hp' : dist p' s.center < s.radius
hp : p' ∈ s
⊢ False

tactic: simp [hp] at hp'
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
hp' : dist p' s.center < s.radius
hp : dist p' s.center = s.radius
⊢ False

tactic: rintro h
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' : P
hp : p ∈ s
hp' : dist p' s.center < s.radius
⊢ p' ≠ secondInter s p (p' -ᵥ p)

tactic: rw [h, mem_sphere.1 ((Sphere.secondInter_mem _).2 hp)] at hp'
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' : P
hp : p ∈ s
hp' : dist p' s.center < s.radius
h : p' = secondInter s p (p' -ᵥ p)
⊢ False

tactic: exact lt_irrefl _ hp'
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' : P
hp : p ∈ s
hp' : s.radius < s.radius
h : p' = secondInter s p (p' -ᵥ p)
⊢ False
Theorem: CategoryTheory.Functor.conj_eqToHom_iff_hEq
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
h : W = Y
h' : X = Z
⊢ f = eqToHom h ≫ g ≫ eqToHom (_ : Z = X) ↔ HEq f g

tactic: cases h'
state_before: case refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Z : C
f : W ⟶ X
h' : X = Z
g : W ⟶ Z
⊢ f = eqToHom (_ : W = W) ≫ g ≫ eqToHom (_ : Z = X) ↔ HEq f g

tactic: simp
state_before: case refl.refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X : C
f g : W ⟶ X
⊢ f = eqToHom (_ : W = W) ≫ g ≫ eqToHom (_ : X = X) ↔ HEq f g
Theorem: Nat.count_eq_card_fintype
File: Mathlib/Data/Nat/Count.lean

tactic: rw [count_eq_card_filter_range, ← Fintype.card_ofFinset, ← CountSet.fintype]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n = Fintype.card { k // k < n ∧ p k }

tactic: rfl
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ (Fintype.card ↑fun x => x < n ∧ p x) = Fintype.card { k // k < n ∧ p k }
Theorem: abs_le_iff_mul_self_le
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [← abs_mul_abs_self, ← abs_mul_abs_self b]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ abs a ≤ abs b ↔ a * a ≤ b * b

tactic: exact mul_self_le_mul_self_iff (abs_nonneg a) (abs_nonneg b)
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ abs a ≤ abs b ↔ abs a * abs a ≤ abs b * abs b
Theorem: Finset.gcd_congr
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: subst hs
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17877
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f✝ f g : β → α
hs : s₁ = s₂
hfg : ∀ (a : β), a ∈ s₂ → f a = g a
⊢ gcd s₁ f = gcd s₂ g

tactic: exact Finset.fold_congr hfg
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17877
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ : Finset β
f✝ f g : β → α
hfg : ∀ (a : β), a ∈ s₁ → f a = g a
⊢ gcd s₁ f = gcd s₁ g
Theorem: Part.div_get_eq
File: Mathlib/Data/Part.lean

tactic: simp [div_def]
state_before: α : Type u_1
β : Type ?u.65716
γ : Type ?u.65719
inst✝ : Div α
a b : Part α
hab : (a / b).Dom
⊢ get (a / b) hab = get a (_ : a.Dom) / get b (_ : b.Dom)

tactic: aesop
state_before: α : Type u_1
β : Type ?u.65716
γ : Type ?u.65719
inst✝ : Div α
a b : Part α
hab : (a / b).Dom
⊢ get (Part.bind a fun y => map (fun x => y / x) b) (_ : (Part.bind a fun y => map (fun x => y / x) b).Dom) =
    get a (_ : a.Dom) / get b (_ : b.Dom)
Theorem: tendsto_rat_cast_atBot_iff
File: Mathlib/Order/Filter/Archimedean.lean

tactic: rw [← @Rat.comap_cast_atBot R, tendsto_comap_iff]
state_before: α : Type u_2
R : Type u_1
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
f : α → ℚ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto f l atBot

tactic: rfl
state_before: α : Type u_2
R : Type u_1
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
f : α → ℚ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto (Rat.cast ∘ f) l atBot