tasksource/leandojo huggingface dataset:
Theorem: Matrix.dotProduct_diagonal
File: Mathlib/Data/Matrix/Basic.lean

tactic: have : ∀ (j) (_ : j ≠ i), v j * diagonal w i j = 0 := fun j hij => by
  simp [diagonal_apply_ne' _ hij]
state_before: l : Type ?u.153650
m : Type u_1
n : Type ?u.153656
o : Type ?u.153659
m' : o → Type ?u.153664
n' : o → Type ?u.153669
R : Type ?u.153672
S : Type ?u.153675
α : Type v
β : Type w
γ : Type ?u.153682
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
⊢ v ⬝ᵥ diagonal w i = v i * w i

tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
state_before: l : Type ?u.153650
m : Type u_1
n : Type ?u.153656
o : Type ?u.153659
m' : o → Type ?u.153664
n' : o → Type ?u.153669
R : Type ?u.153672
S : Type ?u.153675
α : Type v
β : Type w
γ : Type ?u.153682
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → v j * diagonal w i j = 0
⊢ v ⬝ᵥ diagonal w i = v i * w i

tactic: simp [diagonal_apply_ne' _ hij]
state_before: l : Type ?u.153650
m : Type u_1
n : Type ?u.153656
o : Type ?u.153659
m' : o → Type ?u.153664
n' : o → Type ?u.153669
R : Type ?u.153672
S : Type ?u.153675
α : Type v
β : Type w
γ : Type ?u.153682
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i j : m
hij : j ≠ i
⊢ v j * diagonal w i j = 0
Theorem: AList.toFinmap_eq
File: Mathlib/Data/Finmap.lean

tactic: cases s₁
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
⊢ ⟦s₁⟧ = ⟦s₂⟧ ↔ s₁.entries ~ s₂.entries

tactic: cases s₂
state_before: case mk
α : Type u
β : α → Type v
s₂ : AList β
entries✝ : List (Sigma β)
nodupKeys✝ : NodupKeys entries✝
⊢ ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧ = ⟦s₂⟧ ↔
    { entries := entries✝, nodupKeys := nodupKeys✝ }.entries ~ s₂.entries

tactic: simp [AList.toFinmap]
state_before: case mk.mk
α : Type u
β : α → Type v
entries✝¹ : List (Sigma β)
nodupKeys✝¹ : NodupKeys entries✝¹
entries✝ : List (Sigma β)
nodupKeys✝ : NodupKeys entries✝
⊢ ⟦{ entries := entries✝¹, nodupKeys := nodupKeys✝¹ }⟧ = ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧ ↔
    { entries := entries✝¹, nodupKeys := nodupKeys✝¹ }.entries ~
      { entries := entries✝, nodupKeys := nodupKeys✝ }.entries
Theorem: norm_sum_neg_one_pow_le
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rw [neg_one_geom_sum]
state_before: α : Type ?u.1626294
β : Type ?u.1626297
ι : Type ?u.1626300
E : Type ?u.1626303
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
n : ℕ
⊢ ‖∑ i in Finset.range n, (-1) ^ i‖ ≤ 1

tactic: split_ifs <;> norm_num
state_before: α : Type ?u.1626294
β : Type ?u.1626297
ι : Type ?u.1626300
E : Type ?u.1626303
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
n : ℕ
⊢ ‖if Even n then 0 else 1‖ ≤ 1
Theorem: YoungDiagram.transpose_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: ext x
state_before: μ : YoungDiagram
⊢ transpose (transpose μ) = μ

tactic: simp
state_before: case cells.a
μ : YoungDiagram
x : ℕ × ℕ
⊢ x ∈ (transpose (transpose μ)).cells ↔ x ∈ μ.cells
Theorem: Nat.Primrec.add
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: p : ℕ
⊢ unpaired (fun z n => Nat.rec (id z) (fun y IH => succ (unpair (unpair (Nat.pair z (Nat.pair y IH))).snd).snd) n) p =
    unpaired (fun x x_1 => x + x_1) p

tactic: induction p.unpair.2 <;> simp [*, add_succ]
state_before: p : ℕ
⊢ Nat.rec (unpair p).fst (fun y IH => succ IH) (unpair p).snd = (unpair p).fst + (unpair p).snd
Theorem: MeasureTheory.set_lintegral_empty
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [Measure.restrict_empty, lintegral_zero_measure]
state_before: α : Type u_1
β : Type ?u.925342
γ : Type ?u.925345
δ : Type ?u.925348
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (∫⁻ (x : α) in ∅, f x ∂μ) = 0
Theorem: VectorPrebundle.mk_coordChange
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: ext
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ (b, ↑(coordChange a he he' b) v) = ↑e' (totalSpaceMk b (Pretrivialization.symm e b v))

tactic: rw [e.mk_symm hb.1 v, e'.coe_fst', e.proj_symm_apply' hb.1]
state_before: case h₁
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ (b, ↑(coordChange a he he' b) v).fst = (↑e' (totalSpaceMk b (Pretrivialization.symm e b v))).fst

tactic: rw [e.proj_symm_apply' hb.1]
state_before: case h₁
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ TotalSpace.proj (↑(LocalEquiv.symm e.toLocalEquiv) (b, v)) ∈ e'.baseSet

tactic: exact hb.2
state_before: case h₁
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ b ∈ e'.baseSet

tactic: exact a.coordChange_apply he he' hb v
state_before: case h₂
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ (b, ↑(coordChange a he he' b) v).snd = (↑e' (totalSpaceMk b (Pretrivialization.symm e b v))).snd
Theorem: Real.ofCauchy_inf
File: Mathlib/Data/Real/Basic.lean

tactic: rw [inf_def]
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := Quotient.mk equiv (a ⊓ b) } = Real.inf { cauchy := Quotient.mk equiv a } { cauchy := Quotient.mk equiv b }

tactic: rfl
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := Quotient.mk equiv (a ⊓ b) } =
    match { cauchy := Quotient.mk equiv a }, { cauchy := Quotient.mk equiv b } with
    | { cauchy := x }, { cauchy := y } =>
      { cauchy := Quotient.map₂ (fun x x_1 => x ⊓ x_1) Real.definition.proof_2✝ x y }
Theorem: ContinuousLinearEquiv.comp_hasStrictFDerivAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: refine' ⟨fun H => _, fun H => iso.hasStrictFDerivAt.comp x H⟩
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.96628
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
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
⊢ HasStrictFDerivAt (↑iso ∘ f) (comp (↑iso) f') x ↔ HasStrictFDerivAt f f' x

tactic: convert iso.symm.hasStrictFDerivAt.comp x H using 1 <;>
  ext z <;> apply (iso.symm_apply_apply _).symm
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.96628
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
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
H : HasStrictFDerivAt (↑iso ∘ f) (comp (↑iso) f') x
⊢ HasStrictFDerivAt f f' x
Theorem: CharTwo.bit1_eq_one
File: Mathlib/Algebra/CharP/Two.lean

tactic: funext
state_before: R : Type u_1
ι : Type ?u.3727
inst✝¹ : Semiring R
inst✝ : CharP R 2
⊢ bit1 = 1

tactic: simp [bit1]
state_before: case h
R : Type u_1
ι : Type ?u.3727
inst✝¹ : Semiring R
inst✝ : CharP R 2
x✝ : R
⊢ bit1 x✝ = OfNat.ofNat 1 x✝
Theorem: IsLocallyHomeomorphOn.comp
File: Mathlib/Topology/IsLocallyHomeomorph.lean

tactic: intro x hx
state_before: X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
g : Y → Z
f : X → Y
s : Set X
t : Set Y
hg : IsLocallyHomeomorphOn g t
hf : IsLocallyHomeomorphOn f s
h : Set.MapsTo f s t
⊢ IsLocallyHomeomorphOn (g ∘ f) s

tactic: obtain ⟨eg, hxg, rfl⟩ := hg (f x) (h hx)
state_before: X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
g : Y → Z
f : X → Y
s : Set X
t : Set Y
hg : IsLocallyHomeomorphOn g t
hf : IsLocallyHomeomorphOn f s
h : Set.MapsTo f s t
x : X
hx : x ∈ s
⊢ ∃ e, x ∈ e.source ∧ g ∘ f = ↑e

tactic: obtain ⟨ef, hxf, rfl⟩ := hf x hx
state_before: case intro.intro
X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
t : Set Y
hf : IsLocallyHomeomorphOn f s
h : Set.MapsTo f s t
x : X
hx : x ∈ s
eg : LocalHomeomorph Y Z
hxg : f x ∈ eg.source
hg : IsLocallyHomeomorphOn (↑eg) t
⊢ ∃ e, x ∈ e.source ∧ ↑eg ∘ f = ↑e

tactic: exact ⟨ef.trans eg, ⟨hxf, hxg⟩, rfl⟩
state_before: case intro.intro.intro.intro
X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
s : Set X
t : Set Y
x : X
hx : x ∈ s
eg : LocalHomeomorph Y Z
hg : IsLocallyHomeomorphOn (↑eg) t
ef : LocalHomeomorph X Y
hxf : x ∈ ef.source
hf : IsLocallyHomeomorphOn (↑ef) s
h : Set.MapsTo (↑ef) s t
hxg : ↑ef x ∈ eg.source
⊢ ∃ e, x ∈ e.source ∧ ↑eg ∘ ↑ef = ↑e
Theorem: isometry_iff_dist_eq
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [isometry_iff_nndist_eq, ← coe_nndist, NNReal.coe_eq]
state_before: ι : Type ?u.476
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
⊢ Isometry f ↔ ∀ (x y : α), dist (f x) (f y) = dist x y
Theorem: edist_div_left
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, edist_mul_left, edist_inv_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁶ : PseudoEMetricSpace X
inst✝⁵ : Group G
inst✝⁴ : MulAction G X
inst✝³ : IsometricSMul G X
inst✝² : PseudoEMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b c : G
⊢ edist (a / b) (a / c) = edist b c
Theorem: MulAction.Quotient.mk_smul_out'
File: Mathlib/GroupTheory/GroupAction/Quotient.lean

tactic: rw [← Quotient.smul_mk, QuotientGroup.out_eq']
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : Group α
inst✝² : Monoid β
inst✝¹ : MulAction β α
H : Subgroup α
inst✝ : QuotientAction β H
b : β
q : α ⧸ H
⊢ ↑(b • Quotient.out' q) = b • q
Theorem: intervalIntegral.integral_sub_linear_isLittleO_of_tendsto_ae
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa [integral_const] using measure_integral_sub_linear_isLittleO_of_tendsto_ae hfm hf hu hv
state_before: ι : Type u_2
𝕜 : Type ?u.1613008
E : Type u_1
F : Type ?u.1613014
A : Type ?u.1613017
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u✝ v✝ ua ub va vb : ι → ℝ
inst✝² : FTCFilter a la la'
inst✝¹ : FTCFilter b lb lb'
inst✝ : FTCFilter a l l'
hfm : StronglyMeasurableAtFilter f l'
hf : Tendsto f (l' ⊓ Measure.ae volume) (𝓝 c)
u v : ι → ℝ
hu : Tendsto u lt l
hv : Tendsto v lt l
⊢ (fun t => (∫ (x : ℝ) in u t..v t, f x) - (v t - u t) • c) =o[lt] (v - u)
Theorem: MeasureTheory.Measure.restrict_apply_eq_zero'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [restrict_apply' hs]
state_before: α : Type u_1
β : Type ?u.291960
γ : Type ?u.291963
δ : Type ?u.291966
ι : Type ?u.291969
R : Type ?u.291972
R' : Type ?u.291975
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ ↑↑(restrict μ s) t = 0 ↔ ↑↑μ (t ∩ s) = 0
Theorem: Polynomial.leadingCoeff_prod'
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using leadingCoeff_multiset_prod' (s.1.map f) (by simpa using h)
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
h : ∏ i in s, leadingCoeff (f i) ≠ 0
⊢ leadingCoeff (∏ i in s, f i) = ∏ i in s, leadingCoeff (f i)

tactic: simpa using h
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
h : ∏ i in s, leadingCoeff (f i) ≠ 0
⊢ prod (Multiset.map leadingCoeff (Multiset.map f s.val)) ≠ 0
Theorem: MeasureTheory.LpAddConst_of_one_le
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [LpAddConst, if_neg]
state_before: α : Type ?u.3022017
E : Type ?u.3022020
F : Type ?u.3022023
G : Type ?u.3022026
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp : 1 ≤ p
⊢ LpAddConst p = 1

tactic: intro h
state_before: case hnc
α : Type ?u.3022017
E : Type ?u.3022020
F : Type ?u.3022023
G : Type ?u.3022026
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp : 1 ≤ p
⊢ ¬p ∈ Set.Ioo 0 1

tactic: exact lt_irrefl _ (h.2.trans_le hp)
state_before: case hnc
α : Type ?u.3022017
E : Type ?u.3022020
F : Type ?u.3022023
G : Type ?u.3022026
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp : 1 ≤ p
h : p ∈ Set.Ioo 0 1
⊢ False
Theorem: Traversable.id_sequence
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: simp [sequence, traverse_map, id_traverse]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ sequence (pure <$> x) = pure x
Theorem: padicNormE.norm_rat_le_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have : (⟨n, d, hn, hd⟩ : ℚ) = 0 := Rat.zero_iff_num_zero.mpr hnz
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : n = 0
⊢ ‖↑(Rat.mk' n d)‖ ≤ 1

tactic: rw [this]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : n = 0
this : Rat.mk' n d = 0
⊢ ‖↑(Rat.mk' n d)‖ ≤ 1

tactic: norm_num
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : n = 0
this : Rat.mk' n d = 0
⊢ ‖↑0‖ ≤ 1

tactic: have hnz' : (⟨n, d, hn, hd⟩ : ℚ) ≠ 0 := mt Rat.zero_iff_num_zero.1 hnz
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
⊢ ‖↑(Rat.mk' n d)‖ ≤ 1

tactic: rw [padicNormE.eq_padicNorm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ ‖↑(Rat.mk' n d)‖ ≤ 1

tactic: norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ ↑(padicNorm p (Rat.mk' n d)) ≤ 1

tactic: rw [padicNorm.eq_zpow_of_nonzero hnz', padicValRat, neg_sub,
  padicValNat.eq_zero_of_not_dvd hq, Nat.cast_zero, zero_sub, zpow_neg, zpow_ofNat]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ padicNorm p (Rat.mk' n d) ≤ 1

tactic: apply inv_le_one
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ (↑p ^ padicValInt p (Rat.mk' n d).num)⁻¹ ≤ 1

tactic: norm_cast
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ 1 ≤ ↑p ^ padicValInt p (Rat.mk' n d).num

tactic: apply one_le_pow
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ 1 ≤ p ^ padicValInt p (Rat.mk' n d).num

tactic: exact hp.1.pos
state_before: case ha.h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
d : ℕ
hn : d ≠ 0
hd : coprime (Int.natAbs n) d
hq : ¬p ∣ d
hnz : ¬n = 0
hnz' : Rat.mk' n d ≠ 0
⊢ 0 < p
Theorem: Seminorm.cont_withSeminorms_normedSpace
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [← Seminorm.isBounded_const (Fin 1)] at hf
state_before: 𝕜 : Type ?u.643524
𝕜₂ : Type ?u.643527
𝕝 : Type u_4
𝕝₂ : Type u_2
E : Type u_3
F✝ : Type ?u.643539
G : Type ?u.643542
ι : Type u_5
ι' : Type ?u.643548
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : AddCommGroup E
inst✝¹⁵ : Module 𝕜 E
inst✝¹⁴ : NormedField 𝕝
inst✝¹³ : Module 𝕝 E
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : AddCommGroup F✝
inst✝¹⁰ : Module 𝕜₂ F✝
inst✝⁹ : NormedField 𝕝₂
inst✝⁸ : Module 𝕝₂ F✝
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝⁷ : RingHomIsometric σ₁₂
τ₁₂ : 𝕝 →+* 𝕝₂
inst✝⁶ : RingHomIsometric τ₁₂
inst✝⁵ : Nonempty ι
inst✝⁴ : Nonempty ι'
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕝₂ F
inst✝¹ : UniformSpace E
inst✝ : UniformAddGroup E
p : ι → Seminorm 𝕝 E
hp : WithSeminorms p
f : E →ₛₗ[τ₁₂] F
hf : ∃ s C, comp (normSeminorm 𝕝₂ F) f ≤ C • Finset.sup s p
⊢ Continuous ↑f

tactic: exact continuous_from_bounded hp (norm_withSeminorms 𝕝₂ F) f hf
state_before: 𝕜 : Type ?u.643524
𝕜₂ : Type ?u.643527
𝕝 : Type u_4
𝕝₂ : Type u_2
E : Type u_3
F✝ : Type ?u.643539
G : Type ?u.643542
ι : Type u_5
ι' : Type ?u.643548
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : AddCommGroup E
inst✝¹⁵ : Module 𝕜 E
inst✝¹⁴ : NormedField 𝕝
inst✝¹³ : Module 𝕝 E
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : AddCommGroup F✝
inst✝¹⁰ : Module 𝕜₂ F✝
inst✝⁹ : NormedField 𝕝₂
inst✝⁸ : Module 𝕝₂ F✝
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝⁷ : RingHomIsometric σ₁₂
τ₁₂ : 𝕝 →+* 𝕝₂
inst✝⁶ : RingHomIsometric τ₁₂
inst✝⁵ : Nonempty ι
inst✝⁴ : Nonempty ι'
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕝₂ F
inst✝¹ : UniformSpace E
inst✝ : UniformAddGroup E
p : ι → Seminorm 𝕝 E
hp : WithSeminorms p
f : E →ₛₗ[τ₁₂] F
hf : IsBounded p (fun x => normSeminorm 𝕝₂ F) f
⊢ Continuous ↑f
Theorem: ProbabilityTheory.kernel.measure_sum_seq
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [← kernel.sum_apply, kernel_sum_seq κ]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.382317
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ κ : { x // x ∈ kernel α β }
h : IsSFiniteKernel κ
a : α
⊢ (Measure.sum fun n => ↑(seq κ n) a) = ↑κ a
Theorem: Complex.mk_eq_add_mul_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: a b : ℝ
⊢ { re := a, im := b }.re = (↑a + ↑b * I).re ∧ { re := a, im := b }.im = (↑a + ↑b * I).im
Theorem: multiplicity.dvd_of_multiplicity_pos
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← pow_one a]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ a ∣ b

tactic: apply pow_dvd_of_le_multiplicity
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ a ^ 1 ∣ b

tactic: simpa only [Nat.cast_one, PartENat.pos_iff_one_le] using h
state_before: case a
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ ↑1 ≤ multiplicity a b
Theorem: Nat.mod_add_div
File: Std/Data/Nat/Lemmas.lean

tactic: induction m, k using mod.inductionOn with rw [div_eq, mod_eq]
| base x y h => simp [h]
| ind x y h IH => simp [h]; rw [Nat.mul_succ, ← Nat.add_assoc, IH, Nat.sub_add_cancel h.2]
state_before: m k : Nat
⊢ m % k + k * (m / k) = m

tactic: simp [h]
state_before: case base
x y : Nat
h : ¬(0 < y ∧ y ≤ x)
⊢ ((if 0 < y ∧ y ≤ x then (x - y) % y else x) + y * if 0 < y ∧ y ≤ x then (x - y) / y + 1 else 0) = x

tactic: simp [h]
state_before: case ind
x y : Nat
h : 0 < y ∧ y ≤ x
IH : (x - y) % y + y * ((x - y) / y) = x - y
⊢ ((if 0 < y ∧ y ≤ x then (x - y) % y else x) + y * if 0 < y ∧ y ≤ x then (x - y) / y + 1 else 0) = x

tactic: rw [Nat.mul_succ, ← Nat.add_assoc, IH, Nat.sub_add_cancel h.2]
state_before: case ind
x y : Nat
h : 0 < y ∧ y ≤ x
IH : (x - y) % y + y * ((x - y) / y) = x - y
⊢ (x - y) % y + y * ((x - y) / y + 1) = x
Theorem: padicValNat_def'
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValNat, hp, hn]
state_before: p n : ℕ
hp : p ≠ 1
hn : 0 < n
⊢ ↑(padicValNat p n) = multiplicity p n
Theorem: LocalHomeomorph.eventually_ne_nhdsWithin
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [mem_singleton_iff, ← e.left_inv hx, ← h, hx']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.24737
δ : Type ?u.24740
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
hx : x ∈ e.source
x' : α
hx' : ↑(LocalHomeomorph.symm e) (↑e x') = x'
h : ↑e x' = ↑e x
⊢ x' ∈ {x}
Theorem: Ordinal.div_nonempty
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [succ_zero, one_mul] using
  mul_le_mul_right' (succ_le_of_lt (Ordinal.pos_iff_ne_zero.2 h)) (succ a)
state_before: α : Type ?u.224685
β : Type ?u.224688
γ : Type ?u.224691
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : b ≠ 0
⊢ succ a ≤ b * succ a
Theorem: WithBot.map_le_iff
File: Mathlib/Order/WithBot.lean

tactic: simp only [map_bot, bot_le]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.38022
δ : Type ?u.38025
a b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
x✝ : WithBot α
⊢ map f ⊥ ≤ map f x✝ ↔ ⊥ ≤ x✝

tactic: simp only [map_coe, map_bot, coe_ne_bot, not_coe_le_bot _]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.38022
δ : Type ?u.38025
a✝ b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
a : α
⊢ map f ↑a ≤ map f ⊥ ↔ ↑a ≤ ⊥

tactic: simpa only [map_coe, coe_le_coe] using mono_iff
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.38022
δ : Type ?u.38025
a✝ b✝ : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
a b : α
⊢ map f ↑a ≤ map f ↑b ↔ ↑a ≤ ↑b