tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Integrable.real_toNNReal
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: refine'
  ⟨hf.aestronglyMeasurable.aemeasurable.real_toNNReal.coe_nnreal_real.aestronglyMeasurable, _⟩
state_before: α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
⊢ Integrable fun x => ↑(Real.toNNReal (f x))

tactic: rw [hasFiniteIntegral_iff_norm]
state_before: α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
⊢ HasFiniteIntegral fun x => ↑(Real.toNNReal (f x))

tactic: refine' lt_of_le_of_lt _ ((hasFiniteIntegral_iff_norm _).1 hf.hasFiniteIntegral)
state_before: α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
⊢ (∫⁻ (a : α), ENNReal.ofReal ‖↑(Real.toNNReal (f a))‖ ∂μ) < ⊤

tactic: apply lintegral_mono
state_before: α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
⊢ (∫⁻ (a : α), ENNReal.ofReal ‖↑(Real.toNNReal (f a))‖ ∂μ) ≤ ∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ

tactic: intro x
state_before: case hfg
α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
⊢ (fun a => ENNReal.ofReal ‖↑(Real.toNNReal (f a))‖) ≤ fun a => ENNReal.ofReal ‖f a‖

tactic: simp [ENNReal.ofReal_le_ofReal, abs_le, le_abs_self]
state_before: case hfg
α : Type u_1
β : Type ?u.994446
γ : Type ?u.994449
δ : Type ?u.994452
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f
x : α
⊢ (fun a => ENNReal.ofReal ‖↑(Real.toNNReal (f a))‖) x ≤ (fun a => ENNReal.ofReal ‖f a‖) x
Theorem: sup_lt_of_lt_sdiff_right
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← sdiff_sup_cancel hyz]
state_before: α : Type u
β : Type ?u.43541
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z

tactic: refine' (sup_le_sup_right h.le _).lt_of_not_le fun h' => h.not_le _
state_before: α : Type u
β : Type ?u.43541
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z \ y ⊔ y

tactic: rw [← sdiff_idem]
state_before: α : Type u
β : Type ?u.43541
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ z \ y ≤ x

tactic: exact (sdiff_le_sdiff_of_sup_le_sup_right h').trans sdiff_le
state_before: α : Type u
β : Type ?u.43541
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ (z \ y) \ y ≤ x
Theorem: MeasureTheory.SignedMeasure.singularPart_add
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine'
  (eq_singularPart _ (s.rnDeriv μ + t.rnDeriv μ)
      ((mutuallySingular_singularPart s μ).add_left (mutuallySingular_singularPart t μ))
      _).symm
state_before: α : Type u_1
β : Type ?u.638693
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
⊢ singularPart (s + t) μ = singularPart s μ + singularPart t μ

tactic: erw [withDensityᵥ_add (integrable_rnDeriv s μ) (integrable_rnDeriv t μ)]
state_before: α : Type u_1
β : Type ?u.638693
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
⊢ s + t = singularPart s μ + singularPart t μ + withDensityᵥ μ (rnDeriv s μ + rnDeriv t μ)

tactic: rw [add_assoc, add_comm (t.singularPart μ), add_assoc, add_comm _ (t.singularPart μ),
  singularPart_add_withDensity_rnDeriv_eq, ← add_assoc,
  singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type ?u.638693
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
⊢ s + t = singularPart s μ + singularPart t μ + (withDensityᵥ μ (rnDeriv s μ) + withDensityᵥ μ (rnDeriv t μ))
Theorem: Dfinsupp.single_add_erase
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: subst h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : i = i'
⊢ ↑(single i (↑f i) + erase i f) i' = ↑f i'

tactic: simp only [add_apply, single_apply, erase_apply, add_zero, dite_eq_ite, if_true]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
⊢ ↑(single i (↑f i) + erase i f) i = ↑f i

tactic: simp only [add_apply, single_apply, erase_apply, dif_neg h, if_neg (Ne.symm h), zero_add]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : ¬i = i'
⊢ ↑(single i (↑f i) + erase i f) i' = ↑f i'
Theorem: Order.not_isPredLimit
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp
state_before: α : Type u_1
inst✝³ : PartialOrder α
inst✝² : PredOrder α
a b : α
C : α → Sort ?u.21462
inst✝¹ : IsPredArchimedean α
inst✝ : NoMaxOrder α
⊢ ¬IsPredLimit a
Theorem: BoxIntegral.Integrable.hasIntegral
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: rw [integral, dif_pos h]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : Integrable I l f vol
⊢ HasIntegral I l f vol (integral I l f vol)

tactic: exact Classical.choose_spec h
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : Integrable I l f vol
⊢ HasIntegral I l f vol (Exists.choose h)
Theorem: ENNReal.tendsto_atTop_zero
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [true_and]
state_before: α : Type ?u.81159
β : Type u_1
γ : Type ?u.81165
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → ℝ≥0∞
⊢ (∀ (ib : ℝ≥0∞), 0 < ib → ∃ ia, True ∧ ∀ (x : β), x ∈ Ici ia → f x ∈ Iic ib) ↔
    ∀ (ε : ℝ≥0∞), ε > 0 → ∃ N, ∀ (n : β), n ≥ N → f n ≤ ε

tactic: rfl
state_before: α : Type ?u.81159
β : Type u_1
γ : Type ?u.81165
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → ℝ≥0∞
⊢ (∀ (ib : ℝ≥0∞), 0 < ib → ∃ ia, ∀ (x : β), x ∈ Ici ia → f x ∈ Iic ib) ↔
    ∀ (ε : ℝ≥0∞), ε > 0 → ∃ N, ∀ (n : β), n ≥ N → f n ≤ ε
Theorem: PiLp.basisFun_apply
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp_rw [basisFun, Basis.coe_ofEquivFun, PiLp.linearEquiv_symm_apply, Pi.single]
state_before: p : ℝ≥0∞
𝕜 : Type u_2
𝕜' : Type ?u.533812
ι : Type u_1
α : ι → Type ?u.533820
β : ι → Type ?u.533825
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i✝ : ι
ι' : Type ?u.534021
inst✝³ : Fintype ι'
E : Type ?u.534027
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : DecidableEq ι
i : ι
⊢ ↑(basisFun p 𝕜 ι) i = ↑(PiLp.equiv p fun i => 𝕜).symm (Pi.single i 1)
Theorem: ContinuousLinearMap.adjointAux_adjointAux
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: ext v
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.280924
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] F
⊢ ↑adjointAux (↑adjointAux A) = A

tactic: refine' ext_inner_left 𝕜 fun w => _
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.280924
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] F
v : E
⊢ ↑(↑adjointAux (↑adjointAux A)) v = ↑A v

tactic: rw [adjointAux_inner_right, adjointAux_inner_left]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.280924
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] F
v : E
w : (fun x => F) v
⊢ inner w (↑(↑adjointAux (↑adjointAux A)) v) = inner w (↑A v)
Theorem: isCauSeq_of_mono_bounded
File: Mathlib/Data/Complex/Exponential.lean

tactic: refine'
  @Eq.ndrecOn (ℕ → α) _ (IsCauSeq abs) _ _
    (-⟨_, @isCauSeq_of_decreasing_bounded _ _ _ (fun n => -f n) a m (by simpa) (by simpa)⟩ :
        CauSeq α abs).2
state_before: α : Type u_1
β : Type ?u.15452
inst✝³ : Ring β
inst✝² : LinearOrderedField α
inst✝¹ : Archimedean α
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → α
a : α
m : ℕ
ham : ∀ (n : ℕ), n ≥ m → abs' (f n) ≤ a
hnm : ∀ (n : ℕ), n ≥ m → f n ≤ f (Nat.succ n)
⊢ IsCauSeq abs' f

tactic: ext
state_before: α : Type u_1
β : Type ?u.15452
inst✝³ : Ring β
inst✝² : LinearOrderedField α
inst✝¹ : Archimedean α
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → α
a : α
m : ℕ
ham : ∀ (n : ℕ), n ≥ m → abs' (f n) ≤ a
hnm : ∀ (n : ℕ), n ≥ m → f n ≤ f (Nat.succ n)
⊢ ↑(-{ val := fun n => -f n, property := (_ : IsCauSeq abs' fun n => -f n) }) = f

tactic: exact neg_neg _
state_before: case h
α : Type u_1
β : Type ?u.15452
inst✝³ : Ring β
inst✝² : LinearOrderedField α
inst✝¹ : Archimedean α
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → α
a : α
m : ℕ
ham : ∀ (n : ℕ), n ≥ m → abs' (f n) ≤ a
hnm : ∀ (n : ℕ), n ≥ m → f n ≤ f (Nat.succ n)
x✝ : ℕ
⊢ ↑(-{ val := fun n => -f n, property := (_ : IsCauSeq abs' fun n => -f n) }) x✝ = f x✝

tactic: simpa
state_before: α : Type u_1
β : Type ?u.15452
inst✝³ : Ring β
inst✝² : LinearOrderedField α
inst✝¹ : Archimedean α
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → α
a : α
m : ℕ
ham : ∀ (n : ℕ), n ≥ m → abs' (f n) ≤ a
hnm : ∀ (n : ℕ), n ≥ m → f n ≤ f (Nat.succ n)
⊢ ∀ (n : ℕ), n ≥ m → abs' ((fun n => -f n) n) ≤ a

tactic: simpa
state_before: α : Type u_1
β : Type ?u.15452
inst✝³ : Ring β
inst✝² : LinearOrderedField α
inst✝¹ : Archimedean α
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → α
a : α
m : ℕ
ham : ∀ (n : ℕ), n ≥ m → abs' (f n) ≤ a
hnm : ∀ (n : ℕ), n ≥ m → f n ≤ f (Nat.succ n)
⊢ ∀ (n : ℕ), n ≥ m → (fun n => -f n) (Nat.succ n) ≤ (fun n => -f n) n
Theorem: tendsto_atTop_isGLB
File: Mathlib/Topology/Algebra/Order/MonotoneConvergence.lean

tactic: convert tendsto_atBot_isLUB h_anti.dual ha.dual using 1
state_before: α : Type u_2
β : Type ?u.12829
ι : Type u_1
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : InfConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
ha : IsGLB (range f) a
⊢ Tendsto f atTop (𝓝 a)
Theorem: AddLECancellable.tsub_eq_of_eq_add_rev
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm, h]
state_before: α : Type u_1
β : Type ?u.36062
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
h : a = b + c
⊢ a = c + b
Theorem: Metric.diam_univ_of_noncompact
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [diam]
state_before: α : Type u
β : Type v
X : Type ?u.534850
ι : Type ?u.534853
inst✝² : PseudoMetricSpace α
s : Set α
x y z : α
inst✝¹ : ProperSpace α
inst✝ : NoncompactSpace α
⊢ diam univ = 0
Theorem: Filter.EventuallyEq.hasDerivAtFilter_iff
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [h₁]
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 𝕜
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : f₀' = f₁'
⊢ ∀ (x : 𝕜), ↑(smulRight 1 f₀') x = ↑(smulRight 1 f₁') x
Theorem: List.Sublist.eq_of_length
File: Std/Data/List/Lemmas.lean

tactic: rw [s.eq_of_length (succ.inj h)]
state_before: α✝ : Type u_1
l₁ l₂ l₁✝ l₂✝ : List α✝
a : α✝
s : l₁✝ <+ l₂✝
h : length (a :: l₁✝) = length (a :: l₂✝)
⊢ a :: l₁✝ = a :: l₂✝
Theorem: Real.summable_one_div_nat_pow
File: Mathlib/Analysis/PSeries.lean

tactic: simp only [one_div, Real.summable_nat_pow_inv]
state_before: p : ℕ
⊢ (Summable fun n => 1 / ↑n ^ ↑p) ↔ 1 < p
Theorem: Set.union_finset_finite_of_range_finite
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← biUnion_range]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → Finset β
h : Set.Finite (range f)
⊢ Set.Finite (⋃ (a : α), ↑(f a))

tactic: exact h.biUnion fun y _ => y.finite_toSet
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → Finset β
h : Set.Finite (range f)
⊢ Set.Finite (⋃ (x : Finset β) (_ : x ∈ range fun a => f a), ↑x)
Theorem: Filter.bot_coprod_bot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59384
δ : Type ?u.59387
ι : Sort ?u.59390
f : Filter α
g : Filter β
⊢ Filter.coprod ⊥ ⊥ = ⊥
Theorem: Real.coe_fib_eq'
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec.sol_eq_of_eq_init]
state_before: ⊢ (fun n => ↑(Nat.fib n)) = fun n => (φ ^ n - ψ ^ n) / sqrt 5

tactic: intro i hi
state_before: ⊢ Set.EqOn (fun n => ↑(Nat.fib n)) (fun n => (φ ^ n - ψ ^ n) / sqrt 5) ↑(Finset.range fibRec.order)

tactic: norm_cast at hi
state_before: i : ℕ
hi : i ∈ ↑(Finset.range fibRec.order)
⊢ (fun n => ↑(Nat.fib n)) i = (fun n => (φ ^ n - ψ ^ n) / sqrt 5) i

tactic: fin_cases hi
state_before: i : ℕ
hi : i ∈ Finset.range fibRec.order
⊢ (fun n => ↑(Nat.fib n)) i = (fun n => (φ ^ n - ψ ^ n) / sqrt 5) i

tactic: simp
state_before: case head

⊢ (fun n => ↑(Nat.fib n)) 0 = (fun n => (φ ^ n - ψ ^ n) / sqrt 5) 0

tactic: simp only [goldenRatio, goldenConj]
state_before: case tail.head

⊢ (fun n => ↑(Nat.fib n)) 1 = (fun n => (φ ^ n - ψ ^ n) / sqrt 5) 1

tactic: ring_nf
state_before: case tail.head

⊢ ↑(Nat.fib 1) = (((1 + sqrt 5) / 2) ^ 1 - ((1 - sqrt 5) / 2) ^ 1) / sqrt 5

tactic: rw [mul_inv_cancel]
state_before: case tail.head

⊢ 1 = sqrt 5 * (sqrt 5)⁻¹

tactic: norm_num
state_before: case tail.head

⊢ sqrt 5 ≠ 0

tactic: exact fib_isSol_fibRec
state_before: case hu

⊢ LinearRecurrence.IsSolution fibRec fun n => ↑(Nat.fib n)

tactic: suffices LinearRecurrence.IsSolution fibRec
    ((fun n ↦ (sqrt 5)⁻¹ * φ ^ n) - (fun n ↦ (sqrt 5)⁻¹ * ψ ^ n)) by
  convert this
  rw [Pi.sub_apply]
  ring
state_before: case hv

⊢ LinearRecurrence.IsSolution fibRec fun n => (φ ^ n - ψ ^ n) / sqrt 5

tactic: apply (@fibRec ℝ _).solSpace.sub_mem
state_before: case hv

⊢ LinearRecurrence.IsSolution fibRec ((fun n => (sqrt 5)⁻¹ * φ ^ n) - fun n => (sqrt 5)⁻¹ * ψ ^ n)

tactic: convert this
state_before: this : LinearRecurrence.IsSolution fibRec ((fun n => (sqrt 5)⁻¹ * φ ^ n) - fun n => (sqrt 5)⁻¹ * ψ ^ n)
⊢ LinearRecurrence.IsSolution fibRec fun n => (φ ^ n - ψ ^ n) / sqrt 5

tactic: rw [Pi.sub_apply]
state_before: case h.e'_4.h
this : LinearRecurrence.IsSolution fibRec ((fun n => (sqrt 5)⁻¹ * φ ^ n) - fun n => (sqrt 5)⁻¹ * ψ ^ n)
x✝ : ℕ
⊢ (φ ^ x✝ - ψ ^ x✝) / sqrt 5 = ((fun n => (sqrt 5)⁻¹ * φ ^ n) - fun n => (sqrt 5)⁻¹ * ψ ^ n) x✝

tactic: ring
state_before: case h.e'_4.h
this : LinearRecurrence.IsSolution fibRec ((fun n => (sqrt 5)⁻¹ * φ ^ n) - fun n => (sqrt 5)⁻¹ * ψ ^ n)
x✝ : ℕ
⊢ (φ ^ x✝ - ψ ^ x✝) / sqrt 5 = (sqrt 5)⁻¹ * φ ^ x✝ - (sqrt 5)⁻¹ * ψ ^ x✝

tactic: exact Submodule.smul_mem fibRec.solSpace (Real.sqrt 5)⁻¹ geom_gold_isSol_fibRec
state_before: case hv.a

⊢ (fun n => (sqrt 5)⁻¹ * φ ^ n) ∈ LinearRecurrence.solSpace fibRec

tactic: exact Submodule.smul_mem fibRec.solSpace (Real.sqrt 5)⁻¹ geom_goldConj_isSol_fibRec
state_before: case hv.a

⊢ (fun n => (sqrt 5)⁻¹ * ψ ^ n) ∈ LinearRecurrence.solSpace fibRec
Theorem: DihedralGroup.r_one_pow_n
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: rw [r_one_pow, one_def]
state_before: n : ℕ
⊢ r 1 ^ n = 1

tactic: congr 1
state_before: n : ℕ
⊢ r ↑n = r 0

tactic: exact ZMod.nat_cast_self _
state_before: case e_a
n : ℕ
⊢ ↑n = 0
Theorem: CategoryTheory.Limits.MultispanIndex.ι_sndSigmaMap
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: simp [sndSigmaMap]
state_before: C : Type u
inst✝² : Category C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.L
⊢ Sigma.ι I.left b ≫ sndSigmaMap I = snd I b ≫ Sigma.ι I.right (sndFrom I b)
Theorem: CategoryTheory.Idempotents.split_iff_of_iso
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: constructor
state_before: C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ (∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p) ↔ ∃ Y' i' e', i' ≫ e' = 𝟙 Y' ∧ e' ≫ i' = p'

tactic: exact split_imp_of_iso φ p p' hpp'
state_before: case mp
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ (∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p) → ∃ Y' i' e', i' ≫ e' = 𝟙 Y' ∧ e' ≫ i' = p'

tactic: apply split_imp_of_iso φ.symm p' p
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ (∃ Y' i' e', i' ≫ e' = 𝟙 Y' ∧ e' ≫ i' = p') → ∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p

tactic: rw [← comp_id p, ← φ.hom_inv_id]
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ p' ≫ φ.symm.hom = φ.symm.hom ≫ p

tactic: slice_rhs 2 3 => rw [hpp']
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ p' ≫ φ.symm.hom = φ.symm.hom ≫ p ≫ φ.hom ≫ φ.inv

tactic: slice_rhs 1 2 => erw [φ.inv_hom_id]
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ p' ≫ φ.symm.hom = φ.symm.hom ≫ (φ.hom ≫ p') ≫ φ.inv

tactic: simp only [id_comp]
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ p' ≫ φ.symm.hom = (𝟙 X' ≫ p') ≫ φ.inv

tactic: rfl
state_before: case mpr
C : Type u_2
inst✝ : Category C
X X' : C
φ : X ≅ X'
p : X ⟶ X
p' : X' ⟶ X'
hpp' : p ≫ φ.hom = φ.hom ≫ p'
⊢ p' ≫ φ.symm.hom = p' ≫ φ.inv
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_leftUnitor_hom_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (λ_ X).hom.fst = (λ_ X.fst).hom

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).hom.fst = (λ_ (fst✝, snd✝).fst).hom
Theorem: Asymptotics.isBigOWith_norm_right
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def, norm_norm]
state_before: α : Type u_1
β : Type ?u.118286
E : Type u_2
F : Type ?u.118292
G : Type ?u.118295
E' : Type ?u.118298
F' : Type u_3
G' : Type ?u.118304
E'' : Type ?u.118307
F'' : Type ?u.118310
G'' : Type ?u.118313
R : Type ?u.118316
R' : Type ?u.118319
𝕜 : Type ?u.118322
𝕜' : Type ?u.118325
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''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (IsBigOWith c l f fun x => ‖g' x‖) ↔ IsBigOWith c l f g'
Theorem: ENNReal.toReal_inv
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [ENNReal.toReal, toNNReal_inv, NNReal.coe_inv]
state_before: α : Type ?u.837134
β : Type ?u.837137
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toReal a⁻¹ = (ENNReal.toReal a)⁻¹
Theorem: Nat.factors_eq_nil
File: Mathlib/Data/Nat/Factors.lean

tactic: constructor <;> intro h
state_before: n : ℕ
⊢ factors n = [] ↔ n = 0 ∨ n = 1

tactic: rcases n with (_ | _ | n)
state_before: case mp
n : ℕ
h : factors n = []
⊢ n = 0 ∨ n = 1

tactic: exact Or.inl rfl
state_before: case mp.zero
h : factors zero = []
⊢ zero = 0 ∨ zero = 1

tactic: exact Or.inr rfl
state_before: case mp.succ.zero
h : factors (succ zero) = []
⊢ succ zero = 0 ∨ succ zero = 1

tactic: rw [factors] at h
state_before: case mp.succ.succ
n : ℕ
h : factors (succ (succ n)) = []
⊢ succ (succ n) = 0 ∨ succ (succ n) = 1

tactic: injection h
state_before: case mp.succ.succ
n : ℕ
h :
  (let m := minFac (n + 2);
    let_fun this := (_ : (n + 2) / minFac (n + 2) < n + 2);
    m :: factors ((n + 2) / m)) =
    []
⊢ succ (succ n) = 0 ∨ succ (succ n) = 1

tactic: rcases h with (rfl | rfl)
state_before: case mpr
n : ℕ
h : n = 0 ∨ n = 1
⊢ factors n = []

tactic: exact factors_zero
state_before: case mpr.inl

⊢ factors 0 = []

tactic: exact factors_one
state_before: case mpr.inr

⊢ factors 1 = []
Theorem: lineMap_strict_mono_left
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: simp only [lineMap_apply_module]
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.9072
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a < a'
hr : r < 1
⊢ ↑(lineMap a b) r < ↑(lineMap a' b) r

tactic: exact add_lt_add_right (smul_lt_smul_of_pos ha (sub_pos.2 hr)) _
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.9072
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a < a'
hr : r < 1
⊢ (1 - r) • a + r • b < (1 - r) • a' + r • b
Theorem: Multiset.Nodup.le_dedup_iff_le
File: Mathlib/Data/Multiset/Dedup.lean

tactic: simp [le_dedup, hno]
state_before: α : Type u_1
β : Type ?u.14659
inst✝ : DecidableEq α
s t : Multiset α
hno : Nodup s
⊢ s ≤ Multiset.dedup t ↔ s ≤ t
Theorem: CompactSpace.uniformEquicontinuous_of_equicontinuous
File: Mathlib/Topology/UniformSpace/Compact.lean

tactic: rw [equicontinuous_iff_continuous] at h
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.48697
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_1
F : ι → β → α
inst✝ : CompactSpace β
h : Equicontinuous F
⊢ UniformEquicontinuous F

tactic: rw [uniformEquicontinuous_iff_uniformContinuous]
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.48697
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_1
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (↑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformEquicontinuous F

tactic: exact CompactSpace.uniformContinuous_of_continuous h
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.48697
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_1
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (↑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformContinuous (↑UniformFun.ofFun ∘ Function.swap F)