tasksource/leandojo huggingface dataset:
Theorem: tendsto_zpow_atTop_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: lift n to ℕ using hn.le
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
n : ℤ
hn : 0 < n
⊢ Tendsto (fun x => x ^ n) atTop atTop

tactic: simp only [zpow_ofNat]
state_before: case intro
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
n : ℕ
hn : 0 < ↑n
⊢ Tendsto (fun x => x ^ ↑n) atTop atTop

tactic: exact tendsto_pow_atTop (Nat.cast_pos.mp hn).ne'
state_before: case intro
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
n : ℕ
hn : 0 < ↑n
⊢ Tendsto (fun x => x ^ n) atTop atTop
Theorem: tendsto_int_cast_atBot_iff
File: Mathlib/Order/Filter/Archimedean.lean

tactic: rw [← @Int.comap_cast_atBot R, tendsto_comap_iff]
state_before: α : Type u_2
R : Type u_1
inst✝¹ : StrictOrderedRing 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✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atBot ↔ Tendsto (Int.cast ∘ f) l atBot
Theorem: continuous_iff_ultrafilter
File: Mathlib/Topology/Basic.lean

tactic: simp only [continuous_iff_continuousAt, continuousAt_iff_ultrafilter]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.171379
δ : Type ?u.171382
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
⊢ Continuous f ↔ ∀ (x : α) (g : Ultrafilter α), ↑g ≤ 𝓝 x → Tendsto f (↑g) (𝓝 (f x))
Theorem: Multiset.gcd_map_mul
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: refine' s.induction_on _ fun b s ih ↦ _
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s : Multiset α
⊢ gcd (map ((fun x x_1 => x * x_1) a) s) = ↑normalize a * gcd s

tactic: simp_rw [map_zero, gcd_zero, mul_zero]
state_before: case refine'_1
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s : Multiset α
⊢ gcd (map ((fun x x_1 => x * x_1) a) 0) = ↑normalize a * gcd 0

tactic: simp_rw [map_cons, gcd_cons, ← gcd_mul_left]
state_before: case refine'_2
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s✝ : Multiset α
b : α
s : Multiset α
ih : gcd (map ((fun x x_1 => x * x_1) a) s) = ↑normalize a * gcd s
⊢ gcd (map ((fun x x_1 => x * x_1) a) (b ::ₘ s)) = ↑normalize a * gcd (b ::ₘ s)

tactic: rw [ih]
state_before: case refine'_2
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s✝ : Multiset α
b : α
s : Multiset α
ih : gcd (map ((fun x x_1 => x * x_1) a) s) = ↑normalize a * gcd s
⊢ GCDMonoid.gcd (a * b) (gcd (map (fun x => a * x) s)) = GCDMonoid.gcd (a * b) (a * gcd s)

tactic: apply ((normalize_associated a).mul_right _).gcd_eq_right
state_before: case refine'_2
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s✝ : Multiset α
b : α
s : Multiset α
ih : gcd (map ((fun x x_1 => x * x_1) a) s) = ↑normalize a * gcd s
⊢ GCDMonoid.gcd (a * b) (↑normalize a * gcd s) = GCDMonoid.gcd (a * b) (a * gcd s)
Theorem: IsSMulRegular.one
File: Mathlib/Algebra/Regular/SMul.lean

tactic: dsimp only [Function.comp] at ab
state_before: R : Type u_1
S : Type ?u.8602
M : Type u_2
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : (fun x => 1 • x) a = (fun x => 1 • x) b
⊢ a = b

tactic: rw [one_smul, one_smul] at ab
state_before: R : Type u_1
S : Type ?u.8602
M : Type u_2
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : 1 • a = 1 • b
⊢ a = b

tactic: assumption
state_before: R : Type u_1
S : Type ?u.8602
M : Type u_2
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : a = b
⊢ a = b
Theorem: Polynomial.natDegree_multiset_sum_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using natDegree_list_sum_le
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : Multiset S[X]
⊢ ∀ (a : List S[X]),
    natDegree (Multiset.sum (Quotient.mk (List.isSetoid S[X]) a)) ≤
      foldr max (_ : ∀ (a b c : ℕ), max a (max b c) = max b (max a c)) 0
        (Multiset.map natDegree (Quotient.mk (List.isSetoid S[X]) a))
Theorem: edist_le_ofReal
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [edist_dist, ENNReal.ofReal_le_ofReal_iff hr]
state_before: α : Type u
β : Type v
X : Type ?u.23021
ι : Type ?u.23024
inst✝ : PseudoMetricSpace α
x y : α
r : ℝ
hr : 0 ≤ r
⊢ edist x y ≤ ENNReal.ofReal r ↔ dist x y ≤ r
Theorem: smul_smul_smul_comm
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [smul_assoc, smul_assoc, smul_comm b]
state_before: M : Type ?u.11403
N : Type ?u.11406
G : Type ?u.11409
A : Type ?u.11412
B : Type ?u.11415
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : SMul α β
inst✝⁶ : SMul α γ
inst✝⁵ : SMul β δ
inst✝⁴ : SMul α δ
inst✝³ : SMul γ δ
inst✝² : IsScalarTower α β δ
inst✝¹ : IsScalarTower α γ δ
inst✝ : SMulCommClass β γ δ
a : α
b : β
c : γ
d : δ
⊢ (a • b) • c • d = (a • c) • b • d
Theorem: Finset.weightedVSubOfPoint_sdiff_sub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [map_neg, sub_neg_eq_add, s.weightedVSubOfPoint_sdiff h]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.117278
s₂✝ : Finset ι₂
inst✝ : DecidableEq ι
s₂ : Finset ι
h : s₂ ⊆ s
w : ι → k
p : ι → P
b : P
⊢ ↑(weightedVSubOfPoint (s \ s₂) p b) w - ↑(weightedVSubOfPoint s₂ p b) (-w) = ↑(weightedVSubOfPoint s p b) w
Theorem: Ideal.map.isMaximal
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine'
  or_iff_not_imp_left.1 (map_eq_top_or_isMaximal_of_surjective f hf.right H) fun h => H.1.1 _
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Bijective ↑f
I : Ideal R
H : IsMaximal I
⊢ IsMaximal (map f I)

tactic: calc
  I = comap f (map f I) := ((relIsoOfBijective f hf).right_inv I).symm
  _ = comap f ⊤ := by rw [h]
  _ = ⊤ := by rw [comap_top]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Bijective ↑f
I : Ideal R
H : IsMaximal I
h : map f I = ⊤
⊢ I = ⊤

tactic: rw [h]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Bijective ↑f
I : Ideal R
H : IsMaximal I
h : map f I = ⊤
⊢ comap f (map f I) = comap f ⊤

tactic: rw [comap_top]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Bijective ↑f
I : Ideal R
H : IsMaximal I
h : map f I = ⊤
⊢ comap f ⊤ = ⊤
Theorem: Matrix.upper_two_blockTriangular
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rintro (c | c) (d | d) hcd <;> first | simp [hab.not_lt] at hcd ⊢
state_before: α : Type u_1
β : Type ?u.37208
m : Type u_2
n : Type u_3
o : Type ?u.37217
m' : α → Type ?u.37222
n' : α → Type ?u.37227
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b✝ : m → α
inst✝ : Preorder α
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
a b : α
hab : a < b
⊢ BlockTriangular (fromBlocks A B 0 D) (Sum.elim (fun x => a) fun x => b)

tactic: simp [hab.not_lt] at hcd ⊢
state_before: case inr.inr
α : Type u_1
β : Type ?u.37208
m : Type u_2
n : Type u_3
o : Type ?u.37217
m' : α → Type ?u.37222
n' : α → Type ?u.37227
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b✝ : m → α
inst✝ : Preorder α
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
a b : α
hab : a < b
c d : n
hcd : Sum.elim (fun x => a) (fun x => b) (Sum.inr d) < Sum.elim (fun x => a) (fun x => b) (Sum.inr c)
⊢ fromBlocks A B 0 D (Sum.inr c) (Sum.inr d) = 0
Theorem: CategoryTheory.BinaryCofan.mono_inr_of_isVanKampen
File: Mathlib/CategoryTheory/Extensive.lean

tactic: refine' PullbackCone.mono_of_isLimitMkIdId _ (IsPullback.isLimit _)
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ Mono (BinaryCofan.inr c)

tactic: refine' (h (BinaryCofan.mk (initial.to Y) (𝟙 Y)) (mapPair (initial.to X) (𝟙 Y)) c.inr _
    (mapPair_equifibered _)).mp ⟨_⟩ ⟨WalkingPair.right⟩
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsPullback (𝟙 ((pair X Y).obj { as := WalkingPair.right })) (𝟙 ((pair X Y).obj { as := WalkingPair.right }))
    (BinaryCofan.inr c) (BinaryCofan.inr c)

tactic: ext ⟨⟨⟩⟩ <;> dsimp
state_before: case refine'_1
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ mapPair (initial.to X) (𝟙 Y) ≫ c.ι =
    (BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c)

tactic: simp
state_before: case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ initial.to X ≫ BinaryCofan.inl c = initial.to Y ≫ BinaryCofan.inr c

tactic: exact ((BinaryCofan.isColimit_iff_isIso_inr initialIsInitial _).mpr (by
  dsimp
  infer_instance)).some
state_before: case refine'_2
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsColimit (BinaryCofan.mk (initial.to Y) (𝟙 Y))

tactic: dsimp
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (BinaryCofan.inr (BinaryCofan.mk (initial.to Y) (𝟙 Y)))

tactic: infer_instance
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (𝟙 Y)
Theorem: LiouvilleWith.sub_nat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [← Rat.cast_coe_nat, sub_rat_iff]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (x - ↑n) ↔ LiouvilleWith p x
Theorem: CategoryTheory.isSeparator_coprod_of_isSeparator_left
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryCoproduct G H
hG : IsSeparator G
⊢ {G} ⊆ {G, H}
Theorem: Polynomial.natTrailingDegree_nat_cast
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: simp only [← C_eq_nat_cast, natTrailingDegree_C]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ natTrailingDegree ↑n = 0
Theorem: Set.equitableOn_iff_exists_le_le_add_one
File: Mathlib/Data/Set/Equitable.lean

tactic: refine' ⟨_, fun ⟨b, hb⟩ x y hx hy => (hb x hx).2.trans (add_le_add_right (hb y hy).1 _)⟩
state_before: α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
⊢ EquitableOn s f ↔ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: obtain rfl | ⟨x, hx⟩ := s.eq_empty_or_nonempty
state_before: α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
⊢ EquitableOn s f → ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: intro hs
state_before: case inr.intro
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
⊢ EquitableOn s f → ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: by_cases h : ∀ y ∈ s, f x ≤ f y
state_before: case inr.intro
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
⊢ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: push_neg at h
state_before: case neg
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
h : ¬∀ (y : α), y ∈ s → f x ≤ f y
⊢ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: obtain ⟨w, hw, hwx⟩ := h
state_before: case neg
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
h : ∃ y, y ∈ s ∧ f y < f x
⊢ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: refine' ⟨f w, fun y hy => ⟨Nat.le_of_succ_le_succ _, hs hy hw⟩⟩
state_before: case neg.intro.intro
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
w : α
hw : w ∈ s
hwx : f w < f x
⊢ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1

tactic: rw [(Nat.succ_le_of_lt hwx).antisymm (hs hx hw)]
state_before: case neg.intro.intro
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
w : α
hw : w ∈ s
hwx : f w < f x
y : α
hy : y ∈ s
⊢ Nat.succ (f w) ≤ Nat.succ (f y)

tactic: exact hs hx hy
state_before: case neg.intro.intro
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
w : α
hw : w ∈ s
hwx : f w < f x
y : α
hy : y ∈ s
⊢ f x ≤ Nat.succ (f y)

tactic: simp
state_before: case inl
α : Type u_1
β : Type ?u.456
f : α → ℕ
⊢ EquitableOn ∅ f → ∃ b, ∀ (a : α), a ∈ ∅ → b ≤ f a ∧ f a ≤ b + 1

tactic: exact ⟨f x, fun y hy => ⟨h _ hy, hs hy hx⟩⟩
state_before: case pos
α : Type u_1
β : Type ?u.456
s : Set α
f : α → ℕ
x : α
hx : x ∈ s
hs : EquitableOn s f
h : ∀ (y : α), y ∈ s → f x ≤ f y
⊢ ∃ b, ∀ (a : α), a ∈ s → b ≤ f a ∧ f a ≤ b + 1
Theorem: CategoryTheory.Idempotents.Karoubi.hom_ext_iff
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f g : P ⟶ Q
⊢ f = g ↔ f.f = g.f

tactic: intro h
state_before: case mp
C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f g : P ⟶ Q
⊢ f = g → f.f = g.f

tactic: rw [h]
state_before: case mp
C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f g : P ⟶ Q
h : f = g
⊢ f.f = g.f

tactic: apply Hom.ext
state_before: case mpr
C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f g : P ⟶ Q
⊢ f.f = g.f → f = g
Theorem: invOf_mul
File: Mathlib/Algebra/Invertible.lean

tactic: simp [← mul_assoc]
state_before: α : Type u
inst✝³ : Monoid α
a b : α
inst✝² : Invertible a
inst✝¹ : Invertible b
inst✝ : Invertible (a * b)
⊢ a * b * (⅟b * ⅟a) = 1
Theorem: Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: ext y
state_before: ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
⊢ cycleOf (f * g) x = cycleOf f x

tactic: by_cases hxy : (f * g).SameCycle x y
state_before: case H
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y✝ : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
y : α
⊢ ↑(cycleOf (f * g) x) y = ↑(cycleOf f x) y

tactic: obtain ⟨z, rfl⟩ := hxy
state_before: case pos
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y✝ : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
y : α
hxy : SameCycle (f * g) x y
⊢ ↑(cycleOf (f * g) x) y = ↑(cycleOf f x) y

tactic: rw [cycleOf_apply_apply_zpow_self]
state_before: case pos.intro
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
z : ℤ
⊢ ↑(cycleOf (f * g) x) (↑((f * g) ^ z) x) = ↑(cycleOf f x) (↑((f * g) ^ z) x)

tactic: simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
state_before: case pos.intro
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
z : ℤ
⊢ ↑((f * g) ^ (z + 1)) x = ↑(cycleOf f x) (↑((f * g) ^ z) x)

tactic: rw [cycleOf_apply_of_not_sameCycle hxy, cycleOf_apply_of_not_sameCycle]
state_before: case neg
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y✝ : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
y : α
hxy : ¬SameCycle (f * g) x y
⊢ ↑(cycleOf (f * g) x) y = ↑(cycleOf f x) y

tactic: contrapose! hxy
state_before: case neg
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y✝ : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
y : α
hxy : ¬SameCycle (f * g) x y
⊢ ¬SameCycle f x y

tactic: obtain ⟨z, rfl⟩ := hxy
state_before: case neg
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y✝ : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
y : α
hxy : SameCycle f x y
⊢ SameCycle (f * g) x y

tactic: refine' ⟨z, _⟩
state_before: case neg.intro
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
z : ℤ
⊢ SameCycle (f * g) x (↑(f ^ z) x)

tactic: simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
state_before: case neg.intro
ι : Type ?u.2506488
α : Type u_1
β : Type ?u.2506494
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : _root_.Commute f g
x : α
hx : ↑g x = x
z : ℤ
⊢ ↑((f * g) ^ z) x = ↑(f ^ z) x
Theorem: Matrix.conjTranspose_intCast_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.1000581
m : Type u_2
n : Type u_3
o : Type ?u.1000590
m' : o → Type ?u.1000595
n' : o → Type ?u.1000600
R : Type u_1
S : Type ?u.1000606
α : Type v
β : Type w
γ : Type ?u.1000613
inst✝³ : Ring R
inst✝² : AddCommGroup α
inst✝¹ : StarAddMonoid α
inst✝ : Module R α
c : ℤ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (↑c • M)ᴴ i j = (↑c • Mᴴ) i j
Theorem: HahnSeries.single_zero_mul_eq_smul
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
r : R
x : HahnSeries Γ R
⊢ ↑(single 0) r * x = r • x

tactic: exact single_zero_mul_coeff
state_before: case coeff.h
Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
r : R
x : HahnSeries Γ R
x✝ : Γ
⊢ coeff (↑(single 0) r * x) x✝ = coeff (r • x) x✝
Theorem: Real.cosh_add_sinh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ cosh x + sinh x = exp x

tactic: simp
state_before: x y : ℝ
⊢ ↑(cosh x + sinh x) = ↑(exp x)
Theorem: inv_mul_le_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_one]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ b ≤ a * 1 ↔ b ≤ a
Theorem: mem_closure_iff_seq_limit
File: Mathlib/Topology/Sequences.lean

tactic: rw [← seqClosure_eq_closure]
state_before: X : Type u_1
Y : Type ?u.2722
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : FrechetUrysohnSpace X
s : Set X
a : X
⊢ a ∈ closure s ↔ ∃ x, (∀ (n : ℕ), x n ∈ s) ∧ Tendsto x atTop (𝓝 a)

tactic: rfl
state_before: X : Type u_1
Y : Type ?u.2722
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : FrechetUrysohnSpace X
s : Set X
a : X
⊢ a ∈ seqClosure s ↔ ∃ x, (∀ (n : ℕ), x n ∈ s) ∧ Tendsto x atTop (𝓝 a)
Theorem: PicardLindelof.FunSpace.continuous_vComp
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: have := (continuous_subtype_val.prod_mk f.continuous).comp v.continuous_proj
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
⊢ Continuous (vComp f)

tactic: refine' ContinuousOn.comp_continuous v.continuousOn this fun x => _
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
this : Continuous ((fun x => (↑x, toFun f x)) ∘ proj v)
⊢ Continuous (vComp f)

tactic: exact ⟨(v.proj x).2, f.mem_closedBall _⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
this : Continuous ((fun x => (↑x, toFun f x)) ∘ proj v)
x : ℝ
⊢ ((fun x => (↑x, toFun f x)) ∘ proj v) x ∈ Icc v.tMin v.tMax ×ˢ closedBall v.x₀ ↑v.R
Theorem: LinearMap.iInf_ker_proj
File: Mathlib/LinearAlgebra/Pi.lean

tactic: simp only [mem_iInf, mem_ker, proj_apply] at h
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
a : (i : ι) → φ i
h : a ∈ ⨅ (i : ι), ker (proj i)
⊢ a ∈ ⊥

tactic: exact (mem_bot _).2 (funext fun i => h i)
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
a : (i : ι) → φ i
h : ∀ (i : ι), a i = 0
⊢ a ∈ ⊥
Theorem: Function.Periodic.neg
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg, Periodic] using h.sub_eq
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.80217
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
⊢ Periodic f (-c)
Theorem: RatFunc.denom_div_dvd
File: Mathlib/FieldTheory/RatFunc.lean

tactic: by_cases hq : q = 0
state_before: K : Type u
inst✝ : Field K
p q : K[X]
⊢ denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) ∣ q

tactic: rw [denom_div _ hq, C_mul_dvd]
state_before: case neg
K : Type u
inst✝ : Field K
p q : K[X]
hq : ¬q = 0
⊢ denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) ∣ q

tactic: simp [hq]
state_before: case pos
K : Type u
inst✝ : Field K
p q : K[X]
hq : q = 0
⊢ denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) ∣ q

tactic: exact EuclideanDomain.div_dvd_of_dvd (gcd_dvd_right p q)
state_before: case neg
K : Type u
inst✝ : Field K
p q : K[X]
hq : ¬q = 0
⊢ q / gcd p q ∣ q

tactic: simpa only [Ne.def, inv_eq_zero, Polynomial.leadingCoeff_eq_zero] using right_div_gcd_ne_zero hq
state_before: case neg
K : Type u
inst✝ : Field K
p q : K[X]
hq : ¬q = 0
⊢ (leadingCoeff (q / gcd p q))⁻¹ ≠ 0
Theorem: AlternatingMap.map_basis_eq_zero_iff
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u_2
inst✝⁷ : CommRing R
M : Type u_3
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2607358
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type ?u.2607900
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
f : AlternatingMap R M R ι
h : ↑f ↑e = 0
⊢ f = 0

tactic: letI := Classical.decEq ι
state_before: case intro
R : Type u_2
inst✝⁷ : CommRing R
M : Type u_3
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2607358
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type ?u.2607900
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
f : AlternatingMap R M R ι
h : ↑f ↑e = 0
val✝ : Fintype ι
⊢ f = 0

tactic: simpa [h] using f.eq_smul_basis_det e
state_before: case intro
R : Type u_2
inst✝⁷ : CommRing R
M : Type u_3
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2607358
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type ?u.2607900
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
f : AlternatingMap R M R ι
h : ↑f ↑e = 0
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
⊢ f = 0