tasksource/leandojo huggingface dataset:
Theorem: SeparationQuotient.tendsto_lift₂_nhdsWithin
File: Mathlib/Topology/Inseparable.lean

tactic: rw [nhdsWithin, ← map_prod_map_mk_nhds, ← Filter.push_pull, comap_principal]
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.107519
α : Type u_3
ι : Type ?u.107525
π : ι → Type ?u.107530
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s✝ : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
s : Set (SeparationQuotient X × SeparationQuotient Y)
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (𝓝[s] (mk x, mk y)) l ↔ Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l

tactic: rfl
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.107519
α : Type u_3
ι : Type ?u.107525
π : ι → Type ?u.107530
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s✝ : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
s : Set (SeparationQuotient X × SeparationQuotient Y)
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (Filter.map (Prod.map mk mk) (𝓝 (x, y) ⊓ 𝓟 (Prod.map mk mk ⁻¹' s))) l ↔
    Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l
Theorem: Function.minimalPeriod_eq_zero_iff_nmem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← minimalPeriod_pos_iff_mem_periodicPts, not_lt, nonpos_iff_eq_zero]
state_before: α : Type u_1
β : Type ?u.22504
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ minimalPeriod f x = 0 ↔ ¬x ∈ periodicPts f
Theorem: isExposed_empty
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: exfalso
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
x✝ : Set.Nonempty ∅
w✝ : E
hx : w✝ ∈ ∅
⊢ ∃ l, ∅ = {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}

tactic: exact hx
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
x✝ : Set.Nonempty ∅
w✝ : E
hx : w✝ ∈ ∅
⊢ False
Theorem: Uniform.continuousOn_iff'_right
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [ContinuousOn, continuousWithinAt_iff'_right]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.199215
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
s : Set β
⊢ ContinuousOn f s ↔ ∀ (b : β), b ∈ s → Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α)
Theorem: CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (PushoutCocone.unop (colimit.cocone (span f.op g.op))).π.app WalkingCospan.right = pushout.inr.unop
Theorem: Equiv.Perm.IsThreeCycle.orderOf
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [← lcm_cycleType, ht.cycleType, Multiset.lcm_singleton, normalize_eq]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ g : Perm α
ht : IsThreeCycle g
⊢ _root_.orderOf g = 3
Theorem: MeasureTheory.Measure.count_injective_image
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases hs : s.Finite
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.388219
δ : Type ?u.388222
ι : Type ?u.388225
R : Type ?u.388228
R' : Type ?u.388231
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
inst✝ : MeasurableSingletonClass β
f : β → α
hf : Injective f
s : Set β
⊢ ↑↑count (f '' s) = ↑↑count s

tactic: rw [count_apply_infinite hs]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.388219
δ : Type ?u.388222
ι : Type ?u.388225
R : Type ?u.388228
R' : Type ?u.388231
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
inst✝ : MeasurableSingletonClass β
f : β → α
hf : Injective f
s : Set β
hs : ¬Set.Finite s
⊢ ↑↑count (f '' s) = ↑↑count s

tactic: rw [← finite_image_iff <| hf.injOn _] at hs
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.388219
δ : Type ?u.388222
ι : Type ?u.388225
R : Type ?u.388228
R' : Type ?u.388231
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
inst✝ : MeasurableSingletonClass β
f : β → α
hf : Injective f
s : Set β
hs : ¬Set.Finite s
⊢ ↑↑count (f '' s) = ⊤

tactic: rw [count_apply_infinite hs]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.388219
δ : Type ?u.388222
ι : Type ?u.388225
R : Type ?u.388228
R' : Type ?u.388231
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
inst✝ : MeasurableSingletonClass β
f : β → α
hf : Injective f
s : Set β
hs : ¬Set.Finite (f '' s)
⊢ ↑↑count (f '' s) = ⊤

tactic: exact count_injective_image' hf hs.measurableSet (Finite.image f hs).measurableSet
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.388219
δ : Type ?u.388222
ι : Type ?u.388225
R : Type ?u.388228
R' : Type ?u.388231
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
inst✝ : MeasurableSingletonClass β
f : β → α
hf : Injective f
s : Set β
hs : Set.Finite s
⊢ ↑↑count (f '' s) = ↑↑count s
Theorem: SimpleGraph.Walk.map_isPath_of_injective
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ _ ih =>
  rw [Walk.cons_isPath_iff] at hp
  simp [ih hp.1]
  intro x hx hf
  cases hinj hf
  exact hp.2 hx
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
hp : IsPath p
⊢ IsPath (Walk.map f p)

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ : V
hp : IsPath nil
⊢ IsPath (Walk.map f nil)

tactic: rw [Walk.cons_isPath_iff] at hp
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsPath p✝ → IsPath (Walk.map f p✝)
hp : IsPath (cons h✝ p✝)
⊢ IsPath (Walk.map f (cons h✝ p✝))

tactic: simp [ih hp.1]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsPath p✝ → IsPath (Walk.map f p✝)
hp : IsPath p✝ ∧ ¬u✝ ∈ support p✝
⊢ IsPath (Walk.map f (cons h✝ p✝))

tactic: intro x hx hf
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsPath p✝ → IsPath (Walk.map f p✝)
hp : IsPath p✝ ∧ ¬u✝ ∈ support p✝
⊢ ∀ (x : V), x ∈ support p✝ → ¬↑f x = ↑f u✝

tactic: cases hinj hf
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsPath p✝ → IsPath (Walk.map f p✝)
hp : IsPath p✝ ∧ ¬u✝ ∈ support p✝
x : V
hx : x ∈ support p✝
hf : ↑f x = ↑f u✝
⊢ False

tactic: exact hp.2 hx
state_before: case cons.refl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsPath p✝ → IsPath (Walk.map f p✝)
hp : IsPath p✝ ∧ ¬u✝ ∈ support p✝
hx : u✝ ∈ support p✝
hf : ↑f u✝ = ↑f u✝
⊢ False
Theorem: Ordinal.sup_not_succ_of_ne_sup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: by_contra' hoa
state_before: α : Type ?u.283171
β : Type ?u.283174
γ : Type ?u.283177
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal
hf : ∀ (i : ι), f i ≠ sup f
a : Ordinal
hao : a < sup f
⊢ succ a < sup f

tactic: exact
  hao.not_le (sup_le fun i => le_of_lt_succ <| (lt_of_le_of_ne (le_sup _ _) (hf i)).trans_le hoa)
state_before: α : Type ?u.283171
β : Type ?u.283174
γ : Type ?u.283177
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal
hf : ∀ (i : ι), f i ≠ sup f
a : Ordinal
hao : a < sup f
hoa : sup f ≤ succ a
⊢ False
Theorem: Complex.mul_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [normSq, mul_comm, sub_eq_neg_add, add_comm, ofReal']
state_before: z : ℂ
⊢ (z * ↑(starRingEnd ℂ) z).re = (↑(↑normSq z)).re ∧ (z * ↑(starRingEnd ℂ) z).im = (↑(↑normSq z)).im
Theorem: Int.pow_dvd_pow_iff
File: Mathlib/Data/Int/GCD.lean

tactic: refine' ⟨fun h => _, fun h => pow_dvd_pow_of_dvd h _⟩
state_before: m n : ℤ
k : ℕ
k0 : 0 < k
⊢ m ^ k ∣ n ^ k ↔ m ∣ n

tactic: rwa [← natAbs_dvd_natAbs, ← Nat.pow_dvd_pow_iff k0, ← Int.natAbs_pow, ← Int.natAbs_pow,
  natAbs_dvd_natAbs]
state_before: m n : ℤ
k : ℕ
k0 : 0 < k
h : m ^ k ∣ n ^ k
⊢ m ∣ n
Theorem: PadicSeq.norm_zero_iff
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: constructor
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
⊢ norm f = 0 ↔ f ≈ 0

tactic: intro h
state_before: case mp
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
⊢ norm f = 0 → f ≈ 0

tactic: by_contra hf
state_before: case mp
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
h : norm f = 0
⊢ f ≈ 0

tactic: unfold norm at h
state_before: case mp
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
h : norm f = 0
hf : ¬f ≈ 0
⊢ False

tactic: split_ifs at h
state_before: case mp
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
h : (if hf : f ≈ 0 then 0 else padicNorm p (↑f (stationaryPoint hf))) = 0
hf : ¬f ≈ 0
⊢ False

tactic: contradiction
state_before: case mp.inl
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
h✝ : f ≈ 0
h : 0 = 0
⊢ False

case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
⊢ False

tactic: apply hf
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
⊢ False

tactic: intro ε hε
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
⊢ f ≈ 0

tactic: exists stationaryPoint hf
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
ε : ℚ
hε : ε > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → padicNorm p (↑(f - 0) j) < ε

tactic: intro j hj
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
ε : ℚ
hε : ε > 0
⊢ ∀ (j : ℕ), j ≥ stationaryPoint hf → padicNorm p (↑(f - 0) j) < ε

tactic: have heq := stationaryPoint_spec hf le_rfl hj
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
ε : ℚ
hε : ε > 0
j : ℕ
hj : j ≥ stationaryPoint hf
⊢ padicNorm p (↑(f - 0) j) < ε

tactic: simpa [h, heq]
state_before: case mp.inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf h✝ : ¬f ≈ 0
h : padicNorm p (↑f (stationaryPoint h✝)) = 0
ε : ℚ
hε : ε > 0
j : ℕ
hj : j ≥ stationaryPoint hf
heq : padicNorm p (↑f j) = padicNorm p (↑f (stationaryPoint hf))
⊢ padicNorm p (↑(f - 0) j) < ε

tactic: intro h
state_before: case mpr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
⊢ f ≈ 0 → norm f = 0

tactic: simp [norm, h]
state_before: case mpr
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
h : f ≈ 0
⊢ norm f = 0
Theorem: ZMod.valMinAbs_def_pos
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ valMinAbs x = if val x ≤ n / 2 then ↑(val x) else ↑(val x) - ↑n

tactic: cases NeZero.ne 0 rfl
state_before: case zero
inst✝ : NeZero Nat.zero
x : ZMod Nat.zero
⊢ valMinAbs x = if val x ≤ Nat.zero / 2 then ↑(val x) else ↑(val x) - ↑Nat.zero

tactic: rfl
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
x : ZMod (Nat.succ n✝)
⊢ valMinAbs x = if val x ≤ Nat.succ n✝ / 2 then ↑(val x) else ↑(val x) - ↑(Nat.succ n✝)
Theorem: CategoryTheory.NatTrans.exchange
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G H I✝ : C ⥤ D
I J K : D ⥤ E
α : F ⟶ G
β : G ⟶ H
γ : I ⟶ J
δ : J ⟶ K
⊢ (α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫ δ
Theorem: Subgroup.mul_injective_of_disjoint
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: intro x y hxy
state_before: G : Type u_1
G' : Type ?u.729648
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.729657
inst✝¹ : AddGroup A
N : Type ?u.729663
inst✝ : Group N
H₁ H₂ : Subgroup G
h : Disjoint H₁ H₂
⊢ Injective fun g => ↑g.fst * ↑g.snd

tactic: rw [← inv_mul_eq_iff_eq_mul, ← mul_assoc, ← mul_inv_eq_one, mul_assoc] at hxy
state_before: G : Type u_1
G' : Type ?u.729648
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.729657
inst✝¹ : AddGroup A
N : Type ?u.729663
inst✝ : Group N
H₁ H₂ : Subgroup G
h : Disjoint H₁ H₂
x y : { x // x ∈ H₁ } × { x // x ∈ H₂ }
hxy : (fun g => ↑g.fst * ↑g.snd) x = (fun g => ↑g.fst * ↑g.snd) y
⊢ x = y

tactic: replace hxy := disjoint_iff_mul_eq_one.mp h (y.1⁻¹ * x.1).prop (x.2 * y.2⁻¹).prop hxy
state_before: G : Type u_1
G' : Type ?u.729648
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.729657
inst✝¹ : AddGroup A
N : Type ?u.729663
inst✝ : Group N
H₁ H₂ : Subgroup G
h : Disjoint H₁ H₂
x y : { x // x ∈ H₁ } × { x // x ∈ H₂ }
hxy✝ : (↑y.fst)⁻¹ * ↑x.fst * ↑x.snd = ↑y.snd
hxy : (↑y.fst)⁻¹ * ↑x.fst * (↑x.snd * (↑y.snd)⁻¹) = 1
⊢ x = y

tactic: rwa [coe_mul, coe_mul, coe_inv, coe_inv, inv_mul_eq_one, mul_inv_eq_one, ← Subtype.ext_iff, ←
  Subtype.ext_iff, eq_comm, ← Prod.ext_iff] at hxy
state_before: G : Type u_1
G' : Type ?u.729648
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.729657
inst✝¹ : AddGroup A
N : Type ?u.729663
inst✝ : Group N
H₁ H₂ : Subgroup G
h : Disjoint H₁ H₂
x y : { x // x ∈ H₁ } × { x // x ∈ H₂ }
hxy✝ : (↑y.fst)⁻¹ * ↑x.fst * ↑x.snd = ↑y.snd
hxy : ↑(y.fst⁻¹ * x.fst) = 1 ∧ ↑(x.snd * y.snd⁻¹) = 1
⊢ x = y
Theorem: HomologicalComplex.Hom.prev_eq
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.prev_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : Hom C₁ C₂
i j : ι
w : ComplexShape.Rel c i j
⊢ prev f j = (xPrevIso C₁ w).hom ≫ HomologicalComplex.Hom.f f i ≫ (xPrevIso C₂ w).inv

tactic: simp only [xPrevIso, eqToIso_refl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : Hom C₁ C₂
j : ι
w : ComplexShape.Rel c (ComplexShape.prev c j) j
⊢ prev f j = (xPrevIso C₁ w).hom ≫ HomologicalComplex.Hom.f f (ComplexShape.prev c j) ≫ (xPrevIso C₂ w).inv
Theorem: Subgroup.SchurZassenhausInduction.step0
File: Mathlib/GroupTheory/SchurZassenhaus.lean

tactic: rintro rfl
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.coprime (Fintype.card { x // x ∈ N }) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'],
        Nat.coprime (Fintype.card { x // x ∈ N' }) (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
⊢ N ≠ ⊥

tactic: exact h3 ⊤ isComplement'_bot_top
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'],
        Nat.coprime (Fintype.card { x // x ∈ N' }) (index N') → ∃ H', IsComplement' N' H'
inst✝ : Normal ⊥
h1 : Nat.coprime (Fintype.card { x // x ∈ ⊥ }) (index ⊥)
h3 : ∀ (H : Subgroup G), ¬IsComplement' ⊥ H
⊢ False
Theorem: EReal.coe_toReal_le
File: Mathlib/Data/Real/EReal.lean

tactic: by_cases h' : x = ⊤
state_before: x : EReal
h : x ≠ ⊥
⊢ ↑(toReal x) ≤ x

tactic: simp only [h', le_top]
state_before: case pos
x : EReal
h : x ≠ ⊥
h' : x = ⊤
⊢ ↑(toReal x) ≤ x

tactic: simp only [le_refl, coe_toReal h' h]
state_before: case neg
x : EReal
h : x ≠ ⊥
h' : ¬x = ⊤
⊢ ↑(toReal x) ≤ x
Theorem: Bool.not_eq_not
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {a b : Bool}, ¬a = !b ↔ a = b
Theorem: List.Ico.filter_le_of_le
File: Mathlib/Data/List/Intervals.lean

tactic: cases' le_total l m with hlm hml
state_before: n m l : ℕ
hnl : n ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m

tactic: rw [← append_consecutive hnl hlm, filter_append, filter_le_of_top_le (le_refl l),
  filter_le_of_le_bot (le_refl l), nil_append]
state_before: case inl
n m l : ℕ
hnl : n ≤ l
hlm : l ≤ m
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m

tactic: rw [eq_nil_of_le hml, filter_le_of_top_le hml]
state_before: case inr
n m l : ℕ
hnl : n ≤ l
hml : m ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m
Theorem: continuousWithinAt_dslope_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: refine' ⟨ContinuousWithinAt.of_dslope, fun hc => _⟩
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
⊢ ContinuousWithinAt (dslope f a) s b ↔ ContinuousWithinAt f s b

tactic: simp only [dslope, continuousWithinAt_update_of_ne h]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hc : ContinuousWithinAt f s b
⊢ ContinuousWithinAt (dslope f a) s b

tactic: exact ((continuousWithinAt_id.sub continuousWithinAt_const).inv₀ (sub_ne_zero.2 h)).smul
  (hc.sub continuousWithinAt_const)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hc : ContinuousWithinAt f s b
⊢ ContinuousWithinAt (slope f a) s b
Theorem: Set.exists_chain_of_le_chainHeight
File: Mathlib/Order/Height.lean

tactic: cases' (le_top : s.chainHeight ≤ ⊤).eq_or_lt with ha ha <;>
  rw [chainHeight_eq_iSup_subtype] at ha
state_before: α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: obtain ⟨_, ⟨⟨l, h₁, h₂⟩, rfl⟩, h₃⟩ :=
  not_bddAbove_iff'.mp ((WithTop.iSup_coe_eq_top _).mp ha) n
state_before: case inl
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : (⨆ (l : ↑(subchain s)), ↑(length ↑l)) = ⊤
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: exact ⟨l.take n, ⟨h₁.take _, fun x h ↦ h₂ _ <| take_subset _ _ h⟩,
  (l.length_take n).trans <| min_eq_left <| le_of_not_ge h₃⟩
state_before: case inl.intro.intro.intro.mk.intro
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : (⨆ (l : ↑(subchain s)), ↑(length ↑l)) = ⊤
l : List α
h₁ : Chain' (fun x x_1 => x < x_1) l
h₂ : ∀ (i : α), i ∈ l → i ∈ s
h₃ :
  ¬(fun x => ↑(length ↑x)) { val := l, property := (_ : Chain' (fun x x_1 => x < x_1) l ∧ ∀ (i : α), i ∈ l → i ∈ s) } ≤
      n
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: rw [ENat.iSup_coe_lt_top] at ha
state_before: case inr
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : (⨆ (l : ↑(subchain s)), ↑(length ↑l)) < ⊤
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: obtain ⟨⟨l, h₁, h₂⟩, e : l.length = _⟩ := Nat.sSup_mem (Set.range_nonempty _) ha
state_before: case inr
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : BddAbove (range fun l => length ↑l)
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: refine'
  ⟨l.take n, ⟨h₁.take _, fun x h ↦ h₂ _ <| take_subset _ _ h⟩,
    (l.length_take n).trans <| min_eq_left <| _⟩
state_before: case inr.intro.mk.intro
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : BddAbove (range fun l => length ↑l)
l : List α
h₁ : Chain' (fun x x_1 => x < x_1) l
h₂ : ∀ (i : α), i ∈ l → i ∈ s
e : length l = sSup (range fun l => length ↑l)
⊢ ∃ l, l ∈ subchain s ∧ length l = n

tactic: rwa [e, ← Nat.cast_le (α := ℕ∞), sSup_range, ENat.coe_iSup ha, ← chainHeight_eq_iSup_subtype]
state_before: case inr.intro.mk.intro
α : Type u_1
β : Type ?u.3758
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
n : ℕ
hn : ↑n ≤ chainHeight s
ha : BddAbove (range fun l => length ↑l)
l : List α
h₁ : Chain' (fun x x_1 => x < x_1) l
h₂ : ∀ (i : α), i ∈ l → i ∈ s
e : length l = sSup (range fun l => length ↑l)
⊢ n ≤ length l
Theorem: Filter.tendsto_atTop_add_right_of_le'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [hg]
state_before: ι : Type ?u.153094
ι' : Type ?u.153097
α : Type u_1
β : Type u_2
γ : Type ?u.153106
inst✝ : OrderedAddCommGroup β
l : Filter α
f g : α → β
C : β
hf : Tendsto f l atTop
hg : ∀ᶠ (x : α) in l, C ≤ g x
⊢ ∀ᶠ (x : α) in l, (fun x => -g x) x ≤ -C

tactic: simp [hf]
state_before: ι : Type ?u.153094
ι' : Type ?u.153097
α : Type u_1
β : Type u_2
γ : Type ?u.153106
inst✝ : OrderedAddCommGroup β
l : Filter α
f g : α → β
C : β
hf : Tendsto f l atTop
hg : ∀ᶠ (x : α) in l, C ≤ g x
⊢ Tendsto (fun x => (fun x => f x + g x) x + (fun x => -g x) x) l atTop
Theorem: MvPolynomial.degreeOf_lt_iff
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: rwa [degreeOf_eq_sup n f, Finset.sup_lt_iff]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.284872
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
d : ℕ
h : 0 < d
⊢ degreeOf n f < d ↔ ∀ (m : σ →₀ ℕ), m ∈ support f → ↑m n < d
Theorem: Equiv.Perm.decomposeFin_symm_apply_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: simp [Equiv.Perm.decomposeFin]
state_before: n : ℕ
p : Fin (n + 1)
e : Perm (Fin n)
⊢ ↑(↑decomposeFin.symm (p, e)) 0 = p