tasksource/leandojo huggingface dataset:
Theorem: List.formPerm_pow_apply_nthLe
File: Mathlib/GroupTheory/Perm/List.lean

tactic: induction' n with n hn
state_before: α : Type u_1
β : Type ?u.779543
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n k : ℕ
hk : k < length l
⊢ ↑(formPerm l ^ n) (nthLe l k hk) = nthLe l ((k + n) % length l) (_ : (k + n) % length l < length l)

tactic: simp [Nat.mod_eq_of_lt hk]
state_before: case zero
α : Type u_1
β : Type ?u.779543
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
k : ℕ
hk : k < length l
⊢ ↑(formPerm l ^ Nat.zero) (nthLe l k hk) =
    nthLe l ((k + Nat.zero) % length l) (_ : (k + Nat.zero) % length l < length l)

tactic: simp [pow_succ, mul_apply, hn, formPerm_apply_nthLe _ h, Nat.succ_eq_add_one, ← Nat.add_assoc]
state_before: case succ
α : Type u_1
β : Type ?u.779543
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
k : ℕ
hk : k < length l
n : ℕ
hn : ↑(formPerm l ^ n) (nthLe l k hk) = nthLe l ((k + n) % length l) (_ : (k + n) % length l < length l)
⊢ ↑(formPerm l ^ Nat.succ n) (nthLe l k hk) =
    nthLe l ((k + Nat.succ n) % length l) (_ : (k + Nat.succ n) % length l < length l)
Theorem: Asymptotics.IsTheta.zpow
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: cases n
state_before: α : Type u_1
β : Type ?u.46731
E : Type ?u.46734
F : Type ?u.46737
G : Type ?u.46740
E' : Type ?u.46743
F' : Type ?u.46746
G' : Type ?u.46749
E'' : Type ?u.46752
F'' : Type ?u.46755
G'' : Type ?u.46758
R : Type ?u.46761
R' : Type ?u.46764
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
f : α → 𝕜
g : α → 𝕜'
h : f =Θ[l] g
n : ℤ
⊢ (fun x => f x ^ n) =Θ[l] fun x => g x ^ n

tactic: simpa only [Int.ofNat_eq_coe, zpow_coe_nat] using h.pow _
state_before: case ofNat
α : Type u_1
β : Type ?u.46731
E : Type ?u.46734
F : Type ?u.46737
G : Type ?u.46740
E' : Type ?u.46743
F' : Type ?u.46746
G' : Type ?u.46749
E'' : Type ?u.46752
F'' : Type ?u.46755
G'' : Type ?u.46758
R : Type ?u.46761
R' : Type ?u.46764
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
f : α → 𝕜
g : α → 𝕜'
h : f =Θ[l] g
a✝ : ℕ
⊢ (fun x => f x ^ Int.ofNat a✝) =Θ[l] fun x => g x ^ Int.ofNat a✝

tactic: simpa only [zpow_negSucc] using (h.pow _).inv
state_before: case negSucc
α : Type u_1
β : Type ?u.46731
E : Type ?u.46734
F : Type ?u.46737
G : Type ?u.46740
E' : Type ?u.46743
F' : Type ?u.46746
G' : Type ?u.46749
E'' : Type ?u.46752
F'' : Type ?u.46755
G'' : Type ?u.46758
R : Type ?u.46761
R' : Type ?u.46764
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
f : α → 𝕜
g : α → 𝕜'
h : f =Θ[l] g
a✝ : ℕ
⊢ (fun x => f x ^ Int.negSucc a✝) =Θ[l] fun x => g x ^ Int.negSucc a✝
Theorem: Fin.cast_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m n' : ℕ
h : n + 1 = n' + 1
i : Fin n
⊢ ↑(cast h) (↑castSucc i) = ↑castSucc (↑(cast (_ : n = n')) i)

tactic: simp only [coe_cast, coe_castSucc]
state_before: case h
n m n' : ℕ
h : n + 1 = n' + 1
i : Fin n
⊢ ↑(↑(cast h) (↑castSucc i)) = ↑(↑castSucc (↑(cast (_ : n = n')) i))
Theorem: pow_orderOf_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, mul_left_iterate]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
⊢ x ^ orderOf x = ((fun x_1 => x * x_1)^[minimalPeriod (fun x_1 => x * x_1) 1]) 1

tactic: simp only [mul_one]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
⊢ x ^ minimalPeriod (fun x_1 => x * x_1) 1 = (fun x_1 => x ^ minimalPeriod (fun x_2 => x * x_2) 1 * x_1) 1
Theorem: Real.ediam_Ioo
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rcases le_or_lt b a with (h | h)
state_before: α : Type ?u.555240
β : Type ?u.555243
γ : Type ?u.555246
inst✝ : PseudoEMetricSpace α
a b : ℝ
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)

tactic: simp [h]
state_before: case inl
α : Type ?u.555240
β : Type ?u.555243
γ : Type ?u.555246
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : b ≤ a
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)

tactic: rw [Real.ediam_eq (bounded_Ioo _ _), csSup_Ioo h, csInf_Ioo h]
state_before: case inr
α : Type ?u.555240
β : Type ?u.555243
γ : Type ?u.555246
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a < b
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)
Theorem: Units.sq_eq_sq_iff_eq_or_eq_neg
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: simp_rw [ext_iff, val_pow_eq_pow_val, sq_eq_sq_iff_eq_or_eq_neg, Units.val_neg]
state_before: R : Type u_1
S : Type ?u.134487
M : Type ?u.134490
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
a✝ b✝ : R
a b : Rˣ
⊢ a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b
Theorem: LieAlgebra.abelian_derivedAbelianOfIdeal
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: dsimp only [derivedAbelianOfIdeal]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
⊢ IsLieAbelian { x // x ∈ ↑(derivedAbelianOfIdeal I) }

tactic: cases' h : derivedLengthOfIdeal R L I with k
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
⊢ IsLieAbelian
    { x //
      x ∈
        ↑(match derivedLengthOfIdeal R L I with
          | 0 => ⊥
          | Nat.succ k => derivedSeriesOfIdeal R L k I) }

tactic: exact isLieAbelian_bot R L
state_before: case zero
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
h : derivedLengthOfIdeal R L I = Nat.zero
⊢ IsLieAbelian
    { x //
      x ∈
        ↑(match Nat.zero with
          | 0 => ⊥
          | Nat.succ k => derivedSeriesOfIdeal R L k I) }

tactic: rw [derivedSeries_of_derivedLength_succ] at h
state_before: case succ
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
k : ℕ
h : derivedLengthOfIdeal R L I = Nat.succ k
⊢ IsLieAbelian
    { x //
      x ∈
        ↑(match Nat.succ k with
          | 0 => ⊥
          | Nat.succ k => derivedSeriesOfIdeal R L k I) }

tactic: exact h.1
state_before: case succ
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
k : ℕ
h : IsLieAbelian { x // x ∈ ↑(derivedSeriesOfIdeal R L k I) } ∧ derivedSeriesOfIdeal R L k I ≠ ⊥
⊢ IsLieAbelian
    { x //
      x ∈
        ↑(match Nat.succ k with
          | 0 => ⊥
          | Nat.succ k => derivedSeriesOfIdeal R L k I) }
Theorem: Complex.abs_im_lt_abs
File: Mathlib/Data/Complex/Basic.lean

tactic: simpa using @abs_re_lt_abs (z * I)
state_before: z : ℂ
⊢ Abs.abs z.im < ↑abs z ↔ z.re ≠ 0
Theorem: HasStrictDerivAt.const_smul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa using (hf.const_smul c).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
R : Type u_1
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
c : R
hf : HasStrictDerivAt f f' x
⊢ HasStrictDerivAt (fun y => c • f y) (c • f') x
Theorem: MeasureTheory.measure_union₀'
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [union_comm, measure_union₀ hs (AEDisjoint.symm hd), add_comm]
state_before: ι : Type ?u.20428
α : Type u_1
β : Type ?u.20434
γ : Type ?u.20437
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
hd : AEDisjoint μ s t
⊢ ↑↑μ (s ∪ t) = ↑↑μ s + ↑↑μ t
Theorem: TendstoUniformlyOnFilter.prod_map
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOnFilter_iff_tendsto] at h h' ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : TendstoUniformlyOnFilter F f p p'
h' : TendstoUniformlyOnFilter F' f' q q'
⊢ TendstoUniformlyOnFilter (fun i => Prod.map (F i.fst) (F' i.snd)) (Prod.map f f') (p ×ˢ q) (p' ×ˢ q')

tactic: rw [uniformity_prod_eq_comap_prod, tendsto_comap_iff, ← map_swap4_prod, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.snd, F q.fst q.snd)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.snd, F' q.fst q.snd)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto (fun q => (Prod.map f f' q.snd, Prod.map (F q.fst.fst) (F' q.fst.snd) q.snd)) ((p ×ˢ q) ×ˢ p' ×ˢ q')
    (𝓤 (β × β'))

tactic: convert h.prod_map h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.snd, F q.fst q.snd)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.snd, F' q.fst q.snd)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto
    (((fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ∘ fun q =>
        (Prod.map f f' q.snd, Prod.map (F q.fst.fst) (F' q.fst.snd) q.snd)) ∘
      fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd))
    ((p ×ˢ p') ×ˢ q ×ˢ q') (𝓤 β ×ˢ 𝓤 β')
Theorem: image2_upperBounds_lowerBounds_subset_lowerBounds_image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, b, ha, hb, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ image2 f (upperBounds s) (lowerBounds t) ⊆ lowerBounds (image2 f s t)

tactic: exact mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds h₀ h₁ ha hb
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
b : β
ha : a ∈ upperBounds s
hb : b ∈ lowerBounds t
⊢ f a b ∈ lowerBounds (image2 f s t)
Theorem: IsBezout.gcd_dvd_left
File: Mathlib/RingTheory/Bezout.lean

tactic: simp
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsBezout R
x y : R
⊢ x ∈ {x, y}
Theorem: CompositionSeries.ext
File: Mathlib/Order/JordanHolder.lean

tactic: classical
exact List.perm_of_nodup_nodup_toFinset_eq s₁.toList_nodup s₂.toList_nodup
  (Finset.ext <| by simp [*])
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : ∀ (x : X), x ∈ s₁ ↔ x ∈ s₂
⊢ toList s₁ ~ toList s₂

tactic: exact List.perm_of_nodup_nodup_toFinset_eq s₁.toList_nodup s₂.toList_nodup
  (Finset.ext <| by simp [*])
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : ∀ (x : X), x ∈ s₁ ↔ x ∈ s₂
⊢ toList s₁ ~ toList s₂

tactic: simp [*]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : ∀ (x : X), x ∈ s₁ ↔ x ∈ s₂
⊢ ∀ (a : X), a ∈ List.toFinset (toList s₁) ↔ a ∈ List.toFinset (toList s₂)
Theorem: iSup_eq_iSup_of_partialSups_eq_partialSups
File: Mathlib/Order/PartialSups.lean

tactic: simp_rw [← iSup_partialSups_eq f, ← iSup_partialSups_eq g, h]
state_before: α : Type u_1
inst✝ : CompleteLattice α
f g : ℕ → α
h : partialSups f = partialSups g
⊢ (⨆ (n : ℕ), f n) = ⨆ (n : ℕ), g n
Theorem: ApproximatesLinearOn.inverse_continuousOn
File: Mathlib/Analysis/Calculus/Inverse.lean

tactic: apply continuousOn_iff_continuous_restrict.2
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.397883
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.397986
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E ≃L[𝕜] F
s : Set E
c : ℝ≥0
hf : ApproximatesLinearOn f (↑f') s c
hc : Subsingleton E ∨ c < ‖↑(ContinuousLinearEquiv.symm f')‖₊⁻¹
⊢ ContinuousOn (↑(LocalEquiv.symm (toLocalEquiv hf hc))) (f '' s)

tactic: refine' ((hf.antilipschitz hc).to_rightInvOn' _ (hf.toLocalEquiv hc).right_inv').continuous
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.397883
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.397986
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E ≃L[𝕜] F
s : Set E
c : ℝ≥0
hf : ApproximatesLinearOn f (↑f') s c
hc : Subsingleton E ∨ c < ‖↑(ContinuousLinearEquiv.symm f')‖₊⁻¹
⊢ Continuous (restrict (f '' s) ↑(LocalEquiv.symm (toLocalEquiv hf hc)))

tactic: exact fun x hx => (hf.toLocalEquiv hc).map_target hx
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.397883
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.397986
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E ≃L[𝕜] F
s : Set E
c : ℝ≥0
hf : ApproximatesLinearOn f (↑f') s c
hc : Subsingleton E ∨ c < ‖↑(ContinuousLinearEquiv.symm f')‖₊⁻¹
⊢ MapsTo (fun x => LocalEquiv.invFun (toLocalEquiv hf hc) x) (toLocalEquiv hf hc).target s
Theorem: Finset.centroid_pair_fin
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [univ_fin2]
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.492907
s : Finset ι
ι₂ : Type ?u.492913
s₂ : Finset ι₂
inst✝ : Invertible 2
p : Fin 2 → P
⊢ centroid k univ p = 2⁻¹ • (p 1 -ᵥ p 0) +ᵥ p 0

tactic: convert centroid_pair k p 0 1
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.492907
s : Finset ι
ι₂ : Type ?u.492913
s₂ : Finset ι₂
inst✝ : Invertible 2
p : Fin 2 → P
⊢ centroid k {0, 1} p = 2⁻¹ • (p 1 -ᵥ p 0) +ᵥ p 0
Theorem: List.indexOf_get
File: Mathlib/Data/List/Basic.lean

tactic: by_cases h' : a = b <;>
  simp only [h', if_pos, if_false, indexOf_cons, get, @indexOf_get _ _ l]
state_before: ι : Type ?u.92215
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : indexOf a (b :: l) < length (b :: l)
⊢ get (b :: l) { val := indexOf a (b :: l), isLt := h } = a
Theorem: monotone_of_odd_of_monotoneOn_nonneg
File: Mathlib/Order/Monotone/Odd.lean

tactic: refine' MonotoneOn.Iic_union_Ici (fun x hx y hy hxy => neg_le_neg_iff.1 _) h₂
state_before: G : Type u_2
H : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
⊢ Monotone f

tactic: rw [← h₁, ← h₁]
state_before: G : Type u_2
H : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ -f y ≤ -f x

tactic: exact h₂ (neg_nonneg.2 hy) (neg_nonneg.2 hx) (neg_le_neg hxy)
state_before: G : Type u_2
H : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ f (-y) ≤ f (-x)
Theorem: affineIndependent_iff
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: simp [s.weightedVSub_eq_linear_combination hw]
state_before: k : Type u_2
V : Type u_3
P : Type ?u.361200
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι✝ : Type ?u.361850
ι : Type u_1
p : ι → V
s : Finset ι
w : ι → k
hw : ∑ i in s, w i = 0
⊢ (↑(Finset.weightedVSub s p) w = 0 → ∀ (i : ι), i ∈ s → w i = 0) ↔ ∑ e in s, w e • p e = 0 → ∀ (e : ι), e ∈ s → w e = 0
Theorem: Nat.ArithmeticFunction.log_mul_moebius_eq_vonMangoldt
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: rw [← vonMangoldt_mul_zeta, mul_assoc, coe_zeta_mul_coe_moebius, mul_one]
state_before: ⊢ log * ↑μ = Λ
Theorem: Encodable.decode_list_zero
File: Mathlib/Logic/Equiv/List.lean

tactic: rw [decodeList]
state_before: α : Type u_1
inst✝ : Encodable α
⊢ decodeList 0 = some []
Theorem: List.mem_range'_1
File: Std/Data/List/Lemmas.lean

tactic: simp [mem_range']
state_before: m s n : Nat
⊢ m ∈ range' s n ↔ s ≤ m ∧ m < s + n

tactic: exact ⟨
fun ⟨i, h, e⟩ => e ▸ ⟨Nat.le_add_right .., Nat.add_lt_add_left h _⟩,
fun ⟨h₁, h₂⟩ => ⟨m - s, Nat.sub_lt_left_of_lt_add h₁ h₂, (Nat.add_sub_cancel' h₁).symm⟩⟩
state_before: m s n : Nat
⊢ (∃ i, i < n ∧ m = s + i) ↔ s ≤ m ∧ m < s + n
Theorem: Nat.not_dvd_of_pos_of_lt
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rintro ⟨k, rfl⟩
state_before: m n k l : ℕ
h1 : 0 < n
h2 : n < m
⊢ ¬m ∣ n

tactic: rcases Nat.eq_zero_or_pos k with (rfl | hk)
state_before: case intro
m k✝ l k : ℕ
h1 : 0 < m * k
h2 : m * k < m
⊢ False

tactic: exact lt_irrefl 0 h1
state_before: case intro.inl
m k l : ℕ
h1 : 0 < m * 0
h2 : m * 0 < m
⊢ False

tactic: exact not_lt.2 (le_mul_of_pos_right hk) h2
state_before: case intro.inr
m k✝ l k : ℕ
h1 : 0 < m * k
h2 : m * k < m
hk : k > 0
⊢ False
Theorem: Rat.coe_nat_den
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [← Int.cast_ofNat, coe_int_den]
state_before: a b c : ℚ
n : ℕ
⊢ (↑n).den = 1
Theorem: ZNum.le_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← not_lt]
state_before: α : Type ?u.990763
m n : ZNum
⊢ ↑m ≤ ↑n ↔ m ≤ n

tactic: exact not_congr lt_to_int
state_before: α : Type ?u.990763
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n
Theorem: MonoidAlgebra.lift_of
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [of_apply, ← lift_symm_apply, Equiv.symm_apply_apply]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1314142
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.1314179
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
x : G
⊢ ↑(↑(lift k G A) F) (↑(of k G) x) = ↑F x
Theorem: Int.coe_nat_dvd_left
File: Mathlib/Data/Int/Dvd/Basic.lean

tactic: rcases natAbs_eq z with (eq | eq) <;> rw [eq] <;> simp [←coe_nat_dvd]
state_before: n : ℕ
z : ℤ
⊢ ↑n ∣ z ↔ n ∣ natAbs z
Theorem: ENNReal.top_pow
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [pow_succ, hm, top_mul_top]
state_before: α : Type ?u.89016
β : Type ?u.89019
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
h : 0 < n
m : ℕ
x✝ : Nat.succ 0 ≤ m
hm : ⊤ ^ m = ⊤
⊢ ⊤ ^ (m + 1) = ⊤
Theorem: round_eq_zero_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [round_eq, floor_eq_zero_iff, add_mem_Ico_iff_left]
state_before: F : Type ?u.281474
α : Type u_1
β : Type ?u.281480
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
⊢ round x = 0 ↔ x ∈ Ico (-(1 / 2)) (1 / 2)

tactic: norm_num
state_before: F : Type ?u.281474
α : Type u_1
β : Type ?u.281480
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
⊢ x ∈ Ico (0 - 1 / 2) (1 - 1 / 2) ↔ x ∈ Ico (-(1 / 2)) (1 / 2)
Theorem: Equiv.Perm.IsCycleOn.zpow_apply_eq
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [zpow_negSucc, ← inv_pow]
state_before: ι : Type ?u.1696537
α : Type u_1
β : Type ?u.1696543
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℕ
⊢ ↑(f ^ Int.negSucc n) a = a ↔ ↑(card s) ∣ Int.negSucc n

tactic: exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.coe_nat_dvd).symm
state_before: ι : Type ?u.1696537
α : Type u_1
β : Type ?u.1696543
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℕ
⊢ ↑(f⁻¹ ^ (n + 1)) a = a ↔ ↑(card s) ∣ Int.negSucc n
Theorem: List.sections_eq_nil_of_isEmpty
File: Std/Data/List/Basic.lean

tactic: simp only [any, foldr, Bool.or_eq_true] at h
state_before: α : Type u_1
l : List α
L : List (List α)
h : any (l :: L) isEmpty = true
⊢ sections (l :: L) = []

tactic: match l, h with
| [], .inl rfl => simp; induction sections L <;> simp [*]
| l, .inr h => simp [sections, sections_eq_nil_of_isEmpty h]
state_before: α : Type u_1
l : List α
L : List (List α)
h : isEmpty l = true ∨ foldr (fun a r => isEmpty a || r) false L = true
⊢ sections (l :: L) = []

tactic: simp
state_before: α : Type u_1
l : List α
L : List (List α)
h : isEmpty l = true ∨ foldr (fun a r => isEmpty a || r) false L = true
⊢ sections ([] :: L) = []

tactic: induction sections L <;> simp [*]
state_before: α : Type u_1
l : List α
L : List (List α)
h : isEmpty l = true ∨ foldr (fun a r => isEmpty a || r) false L = true
⊢ (List.bind (sections L) fun s => []) = []

tactic: simp [sections, sections_eq_nil_of_isEmpty h]
state_before: α : Type u_1
l✝ : List α
L : List (List α)
h✝ : isEmpty l✝ = true ∨ foldr (fun a r => isEmpty a || r) false L = true
l : List α
h : foldr (fun a r => isEmpty a || r) false L = true
⊢ sections (l :: L) = []