tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Functor.Initial.limit_pre_is_iso_aux
File: Mathlib/CategoryTheory/Limits/Final.lean

tactic: change 𝟙 t.pt ≫ P.lift (extendCone.obj (Cone.whisker F t)) = 𝟙 t.pt
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Initial F
E : Type u₃
inst✝ : Category E
G : D ⥤ E
t : Cone G
P : IsLimit t
⊢ IsLimit.lift (↑(isLimitWhiskerEquiv F t).symm P) (Cone.whisker F t) = 𝟙 t.pt

tactic: apply P.hom_ext
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Initial F
E : Type u₃
inst✝ : Category E
G : D ⥤ E
t : Cone G
P : IsLimit t
⊢ 𝟙 t.pt ≫ IsLimit.lift P (extendCone.obj (Cone.whisker F t)) = 𝟙 t.pt

tactic: intro j
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Initial F
E : Type u₃
inst✝ : Category E
G : D ⥤ E
t : Cone G
P : IsLimit t
⊢ ∀ (j : D), (𝟙 t.pt ≫ IsLimit.lift P (extendCone.obj (Cone.whisker F t))) ≫ t.π.app j = 𝟙 t.pt ≫ t.π.app j

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Initial F
E : Type u₃
inst✝ : Category E
G : D ⥤ E
t : Cone G
P : IsLimit t
j : D
⊢ (𝟙 t.pt ≫ IsLimit.lift P (extendCone.obj (Cone.whisker F t))) ≫ t.π.app j = 𝟙 t.pt ≫ t.π.app j
Theorem: HasFTaylorSeriesUpToOn.congr
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: refine' ⟨fun x hx => _, h.fderivWithin, h.cont⟩
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
h₁ : ∀ (x : E), x ∈ s → f₁ x = f x
⊢ HasFTaylorSeriesUpToOn n f₁ p s

tactic: rw [h₁ x hx]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
h₁ : ∀ (x : E), x ∈ s → f₁ x = f x
x : E
hx : x ∈ s
⊢ ContinuousMultilinearMap.uncurry0 (p x 0) = f₁ x

tactic: exact h.zero_eq x hx
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
h₁ : ∀ (x : E), x ∈ s → f₁ x = f x
x : E
hx : x ∈ s
⊢ ContinuousMultilinearMap.uncurry0 (p x 0) = f x
Theorem: Fin.cycleRange_zero'
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases' n with n
state_before: n : ℕ
h : 0 < n
⊢ cycleRange { val := 0, isLt := h } = 1

tactic: exact cycleRange_zero n
state_before: case succ
n : ℕ
h : 0 < Nat.succ n
⊢ cycleRange { val := 0, isLt := h } = 1

tactic: cases h
state_before: case zero
h : 0 < Nat.zero
⊢ cycleRange { val := 0, isLt := h } = 1
Theorem: Fin.map_valEmbedding_Ioi
File: Mathlib/Data/Fin/Interval.lean

tactic: ext x
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ioi a) = Ioc (↑a) (n - 1)

tactic: simp only [exists_prop, Embedding.coe_subtype, mem_Ioi, mem_map, mem_Ioc]
state_before: case a
n : ℕ
a b : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ioi a) ↔ x ∈ Ioc (↑a) (n - 1)

tactic: constructor
state_before: case a
n : ℕ
a b : Fin n
x : ℕ
⊢ (∃ a_1, a < a_1 ∧ ↑valEmbedding a_1 = x) ↔ ↑a < x ∧ x ≤ n - 1

tactic: cases n
state_before: case a.mpr
n : ℕ
a b : Fin n
x : ℕ
⊢ ↑a < x ∧ x ≤ n - 1 → ∃ a_2, a < a_2 ∧ ↑valEmbedding a_2 = x

tactic: rintro ⟨x, hx, rfl⟩
state_before: case a.mp
n : ℕ
a b : Fin n
x : ℕ
⊢ (∃ a_1, a < a_1 ∧ ↑valEmbedding a_1 = x) → ↑a < x ∧ x ≤ n - 1

tactic: exact ⟨hx, le_tsub_of_add_le_right <| x.2⟩
state_before: case a.mp.intro.intro
n : ℕ
a b x : Fin n
hx : a < x
⊢ ↑a < ↑valEmbedding x ∧ ↑valEmbedding x ≤ n - 1

tactic: exact Fin.elim0 a
state_before: case a.mpr.zero
x : ℕ
a b : Fin Nat.zero
⊢ ↑a < x ∧ x ≤ Nat.zero - 1 → ∃ a_2, a < a_2 ∧ ↑valEmbedding a_2 = x

tactic: exact fun hx => ⟨⟨x, Nat.lt_succ_iff.2 hx.2⟩, hx.1, rfl⟩
state_before: case a.mpr.succ
x n✝ : ℕ
a b : Fin (Nat.succ n✝)
⊢ ↑a < x ∧ x ≤ Nat.succ n✝ - 1 → ∃ a_2, a < a_2 ∧ ↑valEmbedding a_2 = x
Theorem: ContinuousLinearEquiv.comp_differentiableAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [← differentiableWithinAt_univ, ← differentiableWithinAt_univ,
  iso.comp_differentiableWithinAt_iff]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.68075
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
⊢ DifferentiableAt 𝕜 (↑iso ∘ f) x ↔ DifferentiableAt 𝕜 f x
Theorem: or_left_comm
File: Std/Logic.lean

tactic: rw [← or_assoc, ← or_assoc, @or_comm a b]
state_before: a b c : Prop
⊢ a ∨ b ∨ c ↔ b ∨ a ∨ c
Theorem: Irreducible.coprime_iff_not_dvd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: constructor
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
⊢ IsCoprime p n ↔ ¬p ∣ n

tactic: intro co H
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
⊢ IsCoprime p n → ¬p ∣ n

tactic: apply pp.not_unit
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
co : IsCoprime p n
H : p ∣ n
⊢ False

tactic: rw [isUnit_iff_dvd_one]
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
co : IsCoprime p n
H : p ∣ n
⊢ IsUnit p

tactic: apply IsCoprime.dvd_of_dvd_mul_left co
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
co : IsCoprime p n
H : p ∣ n
⊢ p ∣ 1

tactic: rw [mul_one n]
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
co : IsCoprime p n
H : p ∣ n
⊢ p ∣ n * 1

tactic: exact H
state_before: case mp
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
co : IsCoprime p n
H : p ∣ n
⊢ p ∣ n

tactic: intro nd
state_before: case mpr
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
⊢ ¬p ∣ n → IsCoprime p n

tactic: apply isCoprime_of_irreducible_dvd
state_before: case mpr
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
nd : ¬p ∣ n
⊢ IsCoprime p n

tactic: rintro z zi zp zn
state_before: case mpr.H
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
nd : ¬p ∣ n
⊢ ∀ (z : R), Irreducible z → z ∣ p → ¬z ∣ n

tactic: exact nd ((zi.associated_of_dvd pp zp).symm.dvd.trans zn)
state_before: case mpr.H
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
nd : ¬p ∣ n
z : R
zi : Irreducible z
zp : z ∣ p
zn : z ∣ n
⊢ False

tactic: rintro ⟨hp, -⟩
state_before: case mpr.nonzero
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
nd : ¬p ∣ n
⊢ ¬(p = 0 ∧ n = 0)

tactic: exact pp.ne_zero hp
state_before: case mpr.nonzero.intro
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
p n : R
pp : Irreducible p
nd : ¬p ∣ n
hp : p = 0
⊢ False
Theorem: collinear_triple_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: refine' (collinear_insert_insert_insert_left_of_mem_affineSpan_pair h₁ h₂ h₃).subset _
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.333927
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ Collinear k {p₁, p₂, p₃}

tactic: simp [Set.insert_subset_insert]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.333927
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₁, p₂, p₃} ⊆ {p₁, p₂, p₃, p₄}
Theorem: MeasureTheory.Measure.count_apply_infinite
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' top_unique (le_of_tendsto' ENNReal.tendsto_nat_nhds_top fun n => _)
state_before: α : Type u_1
β : Type ?u.374309
γ : Type ?u.374312
δ : Type ?u.374315
ι : Type ?u.374318
R : Type ?u.374321
R' : Type ?u.374324
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
hs : Set.Infinite s
⊢ ↑↑count s = ⊤

tactic: rcases hs.exists_subset_card_eq n with ⟨t, ht, rfl⟩
state_before: α : Type u_1
β : Type ?u.374309
γ : Type ?u.374312
δ : Type ?u.374315
ι : Type ?u.374318
R : Type ?u.374321
R' : Type ?u.374324
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
hs : Set.Infinite s
n : ℕ
⊢ ↑n ≤ ↑↑count s

tactic: calc
  (t.card : ℝ≥0∞) = ∑ i in t, 1 := by simp
  _ = ∑' i : (t : Set α), 1 := (t.tsum_subtype 1).symm
  _ ≤ count (t : Set α) := le_count_apply
  _ ≤ count s := measure_mono ht
state_before: case intro.intro
α : Type u_1
β : Type ?u.374309
γ : Type ?u.374312
δ : Type ?u.374315
ι : Type ?u.374318
R : Type ?u.374321
R' : Type ?u.374324
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
inst✝ : MeasurableSpace α
hs : Set.Infinite s
t : Finset α
ht : ↑t ⊆ s
⊢ ↑(Finset.card t) ≤ ↑↑count s

tactic: simp
state_before: α : Type u_1
β : Type ?u.374309
γ : Type ?u.374312
δ : Type ?u.374315
ι : Type ?u.374318
R : Type ?u.374321
R' : Type ?u.374324
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
inst✝ : MeasurableSpace α
hs : Set.Infinite s
t : Finset α
ht : ↑t ⊆ s
⊢ ↑(Finset.card t) = ∑ i in t, 1
Theorem: Part.Fix.approx_mono
File: Mathlib/Control/LawfulFix.lean

tactic: induction' j with j ih
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i j : ℕ
hij : i ≤ j
⊢ approx (↑f) i ≤ approx (↑f) j

tactic: cases hij
state_before: case succ
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i j✝ : ℕ
hij✝ : i ≤ j✝
j : ℕ
ih : i ≤ j → approx (↑f) i ≤ approx (↑f) j
hij : i ≤ Nat.succ j
⊢ approx (↑f) i ≤ approx (↑f) (Nat.succ j)

tactic: exact le_trans (ih ‹_›) (approx_mono' f)
state_before: case succ.step
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i j✝ : ℕ
hij : i ≤ j✝
j : ℕ
ih : i ≤ j → approx (↑f) i ≤ approx (↑f) j
a✝ : Nat.le i j
⊢ approx (↑f) i ≤ approx (↑f) (Nat.succ j)

tactic: cases hij
state_before: case zero
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i j : ℕ
hij✝ : i ≤ j
hij : i ≤ Nat.zero
⊢ approx (↑f) i ≤ approx (↑f) Nat.zero

tactic: exact le_rfl
state_before: case zero.refl
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
j : ℕ
hij : Nat.zero ≤ j
⊢ approx (↑f) Nat.zero ≤ approx (↑f) Nat.zero

tactic: exact le_rfl
state_before: case succ.refl
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
j✝ j : ℕ
hij : Nat.succ j ≤ j✝
ih : Nat.succ j ≤ j → approx (↑f) (Nat.succ j) ≤ approx (↑f) j
⊢ approx (↑f) (Nat.succ j) ≤ approx (↑f) (Nat.succ j)
Theorem: Real.mul_le_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← inv_div]
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ 2 / π * x ≤ sin x

tactic: simpa [-inv_div, mul_inv_cancel_left₀ pi_div_two_pos.ne'] using @le_sin_mul ((π / 2)⁻¹ * x)
  (mul_nonneg (inv_nonneg.2 pi_div_two_pos.le) hx)
  (by rwa [← div_eq_inv_mul, div_le_one pi_div_two_pos])
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ (π / 2)⁻¹ * x ≤ sin x

tactic: rwa [← div_eq_inv_mul, div_le_one pi_div_two_pos]
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ (π / 2)⁻¹ * x ≤ 1
Theorem: SemiconjBy.inv_inv_symm_iff
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: rw [mul_inv_rev, mul_inv_rev, inv_inv, inv_inv, inv_inv, eq_comm, SemiconjBy]
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a x y : G
⊢ (a⁻¹ * x⁻¹)⁻¹ = (y⁻¹ * a⁻¹)⁻¹ ↔ SemiconjBy a y x
Theorem: padic_polynomial_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [hz]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖Polynomial.eval x F - Polynomial.eval y F‖ = ‖z‖ * ‖x - y‖

tactic: gcongr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖z‖ * ‖x - y‖ ≤ 1 * ‖x - y‖

tactic: apply PadicInt.norm_le_one
state_before: case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖z‖ ≤ 1

tactic: simp
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ 1 * ‖x - y‖ = ‖x - y‖
Theorem: MeasureTheory.SimpleFunc.ennrealRatEmbed_encode
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [ennrealRatEmbed, Encodable.encodek]
state_before: α : Type ?u.833800
β : Type ?u.833803
γ : Type ?u.833806
δ : Type ?u.833809
inst✝ : MeasurableSpace α
K : Type ?u.833815
q : ℚ
⊢ ennrealRatEmbed (Encodable.encode q) = ↑(Real.toNNReal ↑q)

tactic: rfl
state_before: α : Type ?u.833800
β : Type ?u.833803
γ : Type ?u.833806
δ : Type ?u.833809
inst✝ : MeasurableSpace α
K : Type ?u.833815
q : ℚ
⊢ ENNReal.ofReal ↑(Option.getD (Option.some q) 0) = ↑(Real.toNNReal ↑q)
Theorem: Subalgebra.range_algebraMap
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [algebraMap_eq, Algebra.id.map_eq_id, RingHom.id_comp, ← toSubring_subtype,
  Subring.range_subtype]
state_before: R✝ : Type u
A✝ : Type v
B : Type w
inst✝⁷ : CommSemiring R✝
inst✝⁶ : Semiring A✝
inst✝⁵ : Algebra R✝ A✝
inst✝⁴ : Semiring B
inst✝³ : Algebra R✝ B
S✝ : Subalgebra R✝ A✝
α : Type ?u.1952524
β : Type ?u.1952527
R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ RingHom.range (algebraMap { x // x ∈ S } A) = toSubring S
Theorem: Fin.init_update_castSucc
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
⊢ init (update q (↑castSucc i) y) = update (init q) i y

tactic: by_cases h : j = i
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
j : Fin n
⊢ init (update q (↑castSucc i) y) j = update (init q) i y j

tactic: rw [h]
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
j : Fin n
h : j = i
⊢ init (update q (↑castSucc i) y) j = update (init q) i y j

tactic: simp [init]
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
j : Fin n
h : j = i
⊢ init (update q (↑castSucc i) y) i = update (init q) i y i

tactic: simp [init, h]
state_before: case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
j : Fin n
h : ¬j = i
⊢ init (update q (↑castSucc i) y) j = update (init q) i y j
Theorem: MvPolynomial.map_comp_C
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: ext1
state_before: σ : Type u_3
τ : Type ?u.756968
R : Type u_1
S : Type u_2
T : Type ?u.756977
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* S
⊢ RingHom.comp (map f) C = RingHom.comp C f

tactic: apply map_C
state_before: case a
σ : Type u_3
τ : Type ?u.756968
R : Type u_1
S : Type u_2
T : Type ?u.756977
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* S
x✝ : R
⊢ ↑(RingHom.comp (map f) C) x✝ = ↑(RingHom.comp C f) x✝
Theorem: CategoryTheory.Subobject.map_comp
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: induction' x using Quotient.inductionOn' with t
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : Mono f
inst✝ : Mono g
x : Subobject X
⊢ (map (f ≫ g)).obj x = (map g).obj ((map f).obj x)

tactic: exact Quotient.sound ⟨(MonoOver.mapComp _ _).app t⟩
state_before: case h
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : Mono f
inst✝ : Mono g
t : MonoOver X
⊢ (map (f ≫ g)).obj (Quotient.mk'' t) = (map g).obj ((map f).obj (Quotient.mk'' t))
Theorem: CategoryTheory.Iso.cancel_iso_hom_right
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp only [cancel_mono]
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ Z✝ X Y Z : C
f f' : X ⟶ Y
g : Y ≅ Z
⊢ f ≫ g.hom = f' ≫ g.hom ↔ f = f'
Theorem: Nat.div_self
File: Std/Data/Nat/Lemmas.lean

tactic: let t := add_div_right 0 H
state_before: n : Nat
H : 0 < n
⊢ n / n = 1

tactic: rwa [Nat.zero_add, Nat.zero_div] at t
state_before: n : Nat
H : 0 < n
t : (0 + n) / n = succ (0 / n) := add_div_right 0 H
⊢ n / n = 1
Theorem: MeasureTheory.measure_sUnion
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [sUnion_eq_biUnion, measure_biUnion hs hd h]
state_before: α : Type u_1
β : Type ?u.11218
γ : Type ?u.11221
δ : Type ?u.11224
ι : Type ?u.11227
R : Type ?u.11230
R' : Type ?u.11233
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
S : Set (Set α)
hs : Set.Countable S
hd : Set.Pairwise S Disjoint
h : ∀ (s : Set α), s ∈ S → MeasurableSet s
⊢ ↑↑μ (⋃₀ S) = ∑' (s : ↑S), ↑↑μ ↑s
Theorem: MeasureTheory.Measure.haar.prehaar_le_index
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: unfold prehaar
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : Set.Nonempty (interior U)
⊢ prehaar (↑K₀) U K ≤ ↑(index ↑K ↑K₀)

tactic: rw [div_le_iff] <;> norm_cast
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : Set.Nonempty (interior U)
⊢ ↑(index (↑K) U) / ↑(index (↑K₀) U) ≤ ↑(index ↑K ↑K₀)

tactic: apply le_index_mul K₀ K hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : Set.Nonempty (interior U)
⊢ index (↑K) U ≤ index ↑K ↑K₀ * index (↑K₀) U

tactic: exact index_pos K₀ hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : Set.Nonempty (interior U)
⊢ 0 < index (↑K₀) U
Theorem: ContinuousMultilinearMap.norm_map_snoc_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [prod_univ_castSucc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei (↑castSucc i)
x : Ei (last n)
⊢ ‖f‖ * ∏ i : Fin (n + 1), ‖snoc m x i‖ = (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖

tactic: simp [mul_assoc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei (↑castSucc i)
x : Ei (last n)
⊢ ‖f‖ * ((∏ i : Fin n, ‖snoc m x (↑castSucc i)‖) * ‖snoc m x (last n)‖) = (‖f‖ * ∏ i : Fin n, ‖m i‖) * ‖x‖
Theorem: min_def'
File: Mathlib/Order/Basic.lean

tactic: rw [min_def]
state_before: ι : Type ?u.6580
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.6591
r : α → α → Prop
inst✝ : LinearOrder α
a b : α
⊢ min a b = if b ≤ a then b else a

tactic: rcases lt_trichotomy a b with (lt | eq | gt)
state_before: ι : Type ?u.6580
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.6591
r : α → α → Prop
inst✝ : LinearOrder α
a b : α
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: rw [if_pos lt.le, if_neg (not_le.mpr lt)]
state_before: case inl
ι : Type ?u.6580
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.6591
r : α → α → Prop
inst✝ : LinearOrder α
a b : α
lt : a < b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: rw [if_pos eq.le, if_pos eq.ge, eq]
state_before: case inr.inl
ι : Type ?u.6580
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.6591
r : α → α → Prop
inst✝ : LinearOrder α
a b : α
eq : a = b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: rw [if_neg (not_le.mpr gt.gt), if_pos gt.le]
state_before: case inr.inr
ι : Type ?u.6580
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.6591
r : α → α → Prop
inst✝ : LinearOrder α
a b : α
gt : b < a
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a
Theorem: MvPolynomial.constantCoeff_X
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp [constantCoeff_eq]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
i : σ
⊢ ↑constantCoeff (X i) = 0