tasksource/leandojo huggingface dataset:
Theorem: PicardLindelof.FunSpace.hasDerivWithinAt_next
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: haveI : Fact ((t : ℝ) ∈ Icc v.tMin v.tMax) := ⟨t.2⟩
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
⊢ HasDerivWithinAt ((next f).toFun ∘ proj v) (PicardLindelof.toFun v (↑t) (toFun f t)) (Icc v.tMin v.tMax) ↑t

tactic: refine' HasDerivWithinAt.const_add _ _
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
this : Fact (↑t ∈ Icc v.tMin v.tMax)
⊢ HasDerivWithinAt (fun x => v.x₀ + ∫ (τ : ℝ) in ↑v.t₀..↑(proj v x), vComp f τ)
    (PicardLindelof.toFun v (↑t) (toFun f t)) (Icc v.tMin v.tMax) ↑t

tactic: rw [vComp_apply_coe] at this
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
this✝ : Fact (↑t ∈ Icc v.tMin v.tMax)
this : HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..x, vComp f τ) (vComp f ↑t) (Icc v.tMin v.tMax) ↑t
⊢ HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..↑(proj v x), vComp f τ) (PicardLindelof.toFun v (↑t) (toFun f t))
    (Icc v.tMin v.tMax) ↑t

tactic: refine' this.congr_of_eventuallyEq_of_mem _ t.coe_prop
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
this✝ : Fact (↑t ∈ Icc v.tMin v.tMax)
this :
  HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..x, vComp f τ) (PicardLindelof.toFun v (↑t) (toFun f t))
    (Icc v.tMin v.tMax) ↑t
⊢ HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..↑(proj v x), vComp f τ) (PicardLindelof.toFun v (↑t) (toFun f t))
    (Icc v.tMin v.tMax) ↑t

tactic: filter_upwards [self_mem_nhdsWithin] with _ ht'
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
this✝ : Fact (↑t ∈ Icc v.tMin v.tMax)
this :
  HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..x, vComp f τ) (PicardLindelof.toFun v (↑t) (toFun f t))
    (Icc v.tMin v.tMax) ↑t
⊢ (fun x => ∫ (τ : ℝ) in ↑v.t₀..↑(proj v x), vComp f τ) =ᶠ[𝓝[Icc v.tMin v.tMax] ↑t] fun x =>
    ∫ (τ : ℝ) in ↑v.t₀..x, vComp f τ

tactic: rw [v.proj_of_mem ht']
state_before: case h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
t : ↑(Icc v.tMin v.tMax)
this✝ : Fact (↑t ∈ Icc v.tMin v.tMax)
this :
  HasDerivWithinAt (fun x => ∫ (τ : ℝ) in ↑v.t₀..x, vComp f τ) (PicardLindelof.toFun v (↑t) (toFun f t))
    (Icc v.tMin v.tMax) ↑t
a✝ : ℝ
ht' : a✝ ∈ Icc v.tMin v.tMax
⊢ (∫ (τ : ℝ) in ↑v.t₀..↑(proj v a✝), vComp f τ) = ∫ (τ : ℝ) in ↑v.t₀..a✝, vComp f τ
Theorem: VectorBundleCore.localTriv_symmL
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: ext1 v
state_before: R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.445706
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✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
⊢ Trivialization.symmL R (localTriv Z i) b = coordChange Z i (indexAt Z b) b

tactic: rw [(Z.localTriv i).symmL_apply R, (Z.localTriv i).symm_apply]
state_before: case h
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.445706
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✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
v : F
⊢ ↑(Trivialization.symmL R (localTriv Z i) b) v = ↑(coordChange Z i (indexAt Z b) b) v

tactic: exacts [rfl, hb]
state_before: case h
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.445706
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✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
v : F
⊢ cast (_ : Fiber Z (↑(LocalHomeomorph.symm (localTriv Z i).toLocalHomeomorph) (b, v)).fst = Fiber Z b)
      (↑(LocalHomeomorph.symm (localTriv Z i).toLocalHomeomorph) (b, v)).snd =
    ↑(coordChange Z i (indexAt Z b) b) v

case h.hb
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.445706
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✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
v : F
⊢ b ∈ (localTriv Z i).baseSet
Theorem: List.Subperm.filter
File: Mathlib/Data/List/Perm.lean

tactic: obtain ⟨xs, hp, h⟩ := h
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
l l' : List α
h : l <+~ l'
⊢ List.filter p l <+~ List.filter p l'

tactic: exact ⟨_, hp.filter p, h.filter p⟩
state_before: case intro.intro
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
l l' xs : List α
hp : xs ~ l
h : xs <+ l'
⊢ List.filter p l <+~ List.filter p l'
Theorem: MeasurableSpace.DynkinSystem.generateFrom_eq
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rw [ofMeasurableSpace_toMeasurableSpace]
state_before: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
⊢ ofMeasurableSpace
      (toMeasurableSpace (generate s)
        (_ : ∀ (t₁ t₂ : Set α), Has (generate s) t₁ → Has (generate s) t₂ → Has (generate s) (t₁ ∩ t₂))) ≤
    ofMeasurableSpace (generateFrom s)

tactic: exact generate_le _ fun t ht => measurableSet_generateFrom ht
state_before: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
⊢ generate s ≤ ofMeasurableSpace (generateFrom s)
Theorem: ZMod.trace_pow_card
File: Mathlib/LinearAlgebra/Matrix/Charpoly/FiniteField.lean

tactic: have h := FiniteField.trace_pow_card M
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
⊢ trace (M ^ p) = trace M ^ p

tactic: rwa [ZMod.card] at h
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : trace (M ^ Fintype.card (ZMod p)) = trace M ^ Fintype.card (ZMod p)
⊢ trace (M ^ p) = trace M ^ p
Theorem: LinearMap.trace_tensorProduct
File: Mathlib/LinearAlgebra/Trace.lean

tactic: apply
  (compl₁₂_inj (show Surjective (dualTensorHom R M M) from (dualTensorHomEquiv R M M).surjective)
      (show Surjective (dualTensorHom R N N) from (dualTensorHomEquiv R N N).surjective)).1
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.502155
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ compr₂ (mapBilinear R M N M N) (trace R (M ⊗[R] N)) = compl₁₂ (lsmul R R) (trace R M) (trace R N)

tactic: ext (f m g n)
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.502155
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ compl₁₂ (compr₂ (mapBilinear R M N M N) (trace R (M ⊗[R] N))) (dualTensorHom R M M) (dualTensorHom R N N) =
    compl₁₂ (compl₁₂ (lsmul R R) (trace R M) (trace R N)) (dualTensorHom R M M) (dualTensorHom R N N)

tactic: simp only [AlgebraTensorModule.curry_apply_apply, toFun_eq_coe, TensorProduct.curry_apply,
  coe_restrictScalars, compl₁₂_apply, compr₂_apply, mapBilinear_apply,
  trace_eq_contract_apply, contractLeft_apply, lsmul_apply, Algebra.id.smul_eq_mul,
  map_dualTensorHom, dualDistrib_apply]
state_before: case a.h.h.a.h.h
R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.502155
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : Module.Dual R M
m : M
g : Module.Dual R N
n : N
⊢ ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry
                        (compl₁₂ (compr₂ (mapBilinear R M N M N) (trace R (M ⊗[R] N))) (dualTensorHom R M M)
                          (dualTensorHom R N N)))
                    f)
                m))
          g)
      n =
    ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry
                        (compl₁₂ (compl₁₂ (lsmul R R) (trace R M) (trace R N)) (dualTensorHom R M M)
                          (dualTensorHom R N N)))
                    f)
                m))
          g)
      n
Theorem: BoxIntegral.Box.splitUpper_def
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp only [splitUpper, mk'_eq_coe, max_eq_left h.1.le, update]
state_before: ι : Type u_1
M : Type ?u.18967
n : ℕ
I : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
inst✝ : DecidableEq ι
i : ι
x : ℝ
h : x ∈ Ioo (lower I i) (upper I i)
h' : optParam (∀ (j : ι), update I.lower i x j < upper I j) (_ : ∀ (x_1 : ι), update I.lower i x x_1 < upper I x_1)
⊢ splitUpper I i x = ↑{ lower := update I.lower i x, upper := I.upper, lower_lt_upper := h' }
Theorem: MeasureTheory.set_integral_ge_of_const_le
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [mul_comm, ← smul_eq_mul, ← set_integral_const c]
state_before: α : Type u_1
β : Type ?u.290238
E : Type ?u.290241
F : Type ?u.290244
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s t : Set α
hf✝ : IntegrableOn f s
hg : IntegrableOn g s
c : ℝ
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
hf : ∀ (x : α), x ∈ s → c ≤ f x
hfint : IntegrableOn (fun x => f x) s
⊢ c * ENNReal.toReal (↑↑μ s) ≤ ∫ (x : α) in s, f x ∂μ

tactic: exact set_integral_mono_on (integrableOn_const.2 (Or.inr hμs.lt_top)) hfint hs hf
state_before: α : Type u_1
β : Type ?u.290238
E : Type ?u.290241
F : Type ?u.290244
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s t : Set α
hf✝ : IntegrableOn f s
hg : IntegrableOn g s
c : ℝ
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
hf : ∀ (x : α), x ∈ s → c ≤ f x
hfint : IntegrableOn (fun x => f x) s
⊢ (∫ (x : α) in s, c ∂μ) ≤ ∫ (x : α) in s, f x ∂μ
Theorem: FirstOrder.Language.realize_noBotOrder_iff
File: Mathlib/ModelTheory/Order.lean

tactic: simp only [noBotOrderSentence, Sentence.Realize, Formula.Realize, BoundedFormula.realize_all,
  BoundedFormula.realize_ex, BoundedFormula.realize_not, Term.realize, Term.realize_le,
  Sum.elim_inr]
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ M ⊨ noBotOrderSentence Language.order ↔ NoBotOrder M

tactic: refine' ⟨fun h => ⟨fun a => h a⟩, _⟩
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ (∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 0 ≤ Fin.snoc (Fin.snoc default a) a_1 1) ↔ NoBotOrder M

tactic: intro h a
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ NoBotOrder M → ∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 0 ≤ Fin.snoc (Fin.snoc default a) a_1 1

tactic: exact exists_not_ge a
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
h : NoBotOrder M
a : M
⊢ ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 0 ≤ Fin.snoc (Fin.snoc default a) a_1 1
Theorem: Ordinal.principal_mul_omega
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: dsimp only
state_before: a b : Ordinal
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ (fun x x_1 => x * x_1) ↑m ↑n < ω

tactic: rw [← nat_cast_mul]
state_before: a b : Ordinal
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑m * ↑n < ω

tactic: apply nat_lt_omega
state_before: a b : Ordinal
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑(m * n) < ω
Theorem: List.permutationsAux2_append
File: Mathlib/Data/List/Permutation.lean

tactic: induction ys generalizing f <;> simp [*]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts [] ys f).snd ++ r = (permutationsAux2 t ts r ys f).snd
Theorem: Real.Angle.cos_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ₂ using Real.Angle.induction_on
state_before: θ₁ θ₂ : Angle
⊢ cos (θ₁ + θ₂) = cos θ₁ * cos θ₂ - sin θ₁ * sin θ₂

tactic: induction θ₁ using Real.Angle.induction_on
state_before: case h
θ₁ : Angle
x✝ : ℝ
⊢ cos (θ₁ + ↑x✝) = cos θ₁ * cos ↑x✝ - sin θ₁ * sin ↑x✝

tactic: exact Real.cos_add _ _
state_before: case h.h
x✝¹ x✝ : ℝ
⊢ cos (↑x✝ + ↑x✝¹) = cos ↑x✝ * cos ↑x✝¹ - sin ↑x✝ * sin ↑x✝¹
Theorem: Nat.le_min
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.min_def]
state_before: a b c : Nat
x✝ : a ≤ b ∧ a ≤ c
h₁ : a ≤ b
h₂ : a ≤ c
⊢ a ≤ min b c

tactic: split <;> assumption
state_before: a b c : Nat
x✝ : a ≤ b ∧ a ≤ c
h₁ : a ≤ b
h₂ : a ≤ c
⊢ a ≤ if b ≤ c then b else c
Theorem: bit1_injective
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: simp only [bit1, add_left_inj] at h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : bit1 a = bit1 b
⊢ a = b

tactic: exact bit0_injective h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : bit0 a = bit0 b
⊢ a = b
Theorem: Nat.eq_of_mul_eq_mul_right
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.mul_comm n m, Nat.mul_comm k m] at h
state_before: n m k : Nat
hm : 0 < m
h : n * m = k * m
⊢ n = k

tactic: exact Nat.eq_of_mul_eq_mul_left hm h
state_before: n m k : Nat
hm : 0 < m
h : m * n = m * k
⊢ n = k
Theorem: List.dropLast_eq_dropLastTR
File: Std/Data/List/Basic.lean

tactic: funext α l
state_before: ⊢ @dropLast = @dropLastTR

tactic: simp [dropLastTR]
state_before: case h.h
α : Type u_1
l : List α
⊢ dropLast l = dropLastTR l
Theorem: ball_sub_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: simp_rw [sub_eq_add_neg, neg_closedBall, ball_add_closedBall hε hδ]
state_before: 𝕜 : Type ?u.1069697
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 ≤ δ
a b : E
⊢ Metric.ball a ε - Metric.closedBall b δ = Metric.ball (a - b) (ε + δ)
Theorem: Int.floor_nonneg
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_floor, Int.cast_zero]
state_before: F : Type ?u.122679
α : Type u_1
β : Type ?u.122685
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ 0 ≤ ⌊a⌋ ↔ 0 ≤ a
Theorem: MeasureTheory.Measure.integral_comp_inv_mul_right
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simpa only [mul_comm] using integral_comp_inv_mul_left g a
state_before: E : Type ?u.97935
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
g : ℝ → F
a : ℝ
⊢ (∫ (x : ℝ), g (x * a⁻¹)) = abs a • ∫ (y : ℝ), g y
Theorem: Dense.eq_of_sub_mem_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [dense_iff_topologicalClosure_eq_top, topologicalClosure_eq_top_iff] at hK
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.890931
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
inst✝ : CompleteSpace E
hK : Dense ↑K
h : x - y ∈ Kᗮ
⊢ x = y

tactic: rwa [hK, Submodule.mem_bot, sub_eq_zero] at h
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.890931
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
inst✝ : CompleteSpace E
hK✝ : Dense ↑K
hK : Kᗮ = ⊥
h : x - y ∈ Kᗮ
⊢ x = y
Theorem: Rat.num_mk
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rcases d with ((_ | _) | _) <;>
rw [←Int.div_eq_ediv_of_dvd] <;>
simp [divInt, mkRat, Rat.normalize, Nat.succPNat, Int.sign, Int.gcd, -Nat.cast_succ,
  Int.zero_ediv, Int.ofNat_dvd_left, Nat.gcd_dvd_left]
state_before: n d : ℤ
⊢ (n /. d).num = Int.sign d * n / ↑(Int.gcd n d)
Theorem: IsBoundedLinearMap.fderivWithin
File: Mathlib/Analysis/Calculus/FDeriv/Linear.lean

tactic: rw [DifferentiableAt.fderivWithin h.differentiableAt hxs]
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.65006
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.65101
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
h : IsBoundedLinearMap 𝕜 f
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ _root_.fderivWithin 𝕜 f s x = toContinuousLinearMap h

tactic: exact h.fderiv
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.65006
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.65101
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
h : IsBoundedLinearMap 𝕜 f
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ _root_.fderiv 𝕜 f x = toContinuousLinearMap h
Theorem: Option.elim_none_some
File: Mathlib/Data/Option/Basic.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20379
δ : Type ?u.20382
f : Option α → β
o : Option α
⊢ Option.elim o (f none) (f ∘ some) = f o
Theorem: add_le_iff
File: Mathlib/Algebra/Order/Kleene.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.22650
ι : Type ?u.22653
π : ι → Type ?u.22658
inst✝ : IdemSemiring α
a b c : α
⊢ a + b ≤ c ↔ a ≤ c ∧ b ≤ c
Theorem: Dfinsupp.support_filter
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
⊢ support (filter p f) = Finset.filter p (support f)

tactic: by_cases h : p i <;> simp [h]
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ i ∈ support (filter p f) ↔ i ∈ Finset.filter p (support f)
Theorem: Finset.singleton_inter_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [insert_inter_of_mem H, empty_inter]
state_before: α : Type u_1
β : Type ?u.186600
γ : Type ?u.186603
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
H : a ∈ s
⊢ insert a ∅ ∩ s = insert a ∅
Theorem: iteratedDeriv_eq_iterate
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: ext x
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.135983
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv n f = (deriv^[n]) f

tactic: rw [← iteratedDerivWithin_univ]
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.135983
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv n f x = (deriv^[n]) f x

tactic: convert iteratedDerivWithin_eq_iterate uniqueDiffOn_univ (F := F) (mem_univ x)
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.135983
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDerivWithin n f univ x = (deriv^[n]) f x

tactic: simp [derivWithin_univ]
state_before: case h.e'_3.h.e'_1.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.135983
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝¹ x : 𝕜
x✝ : 𝕜 → F
⊢ deriv x✝ = derivWithin x✝ univ
Theorem: Matrix.inv_diagonal
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [nonsing_inv_eq_ring_inverse]
state_before: l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ (diagonal v)⁻¹ = diagonal (Ring.inverse v)

tactic: by_cases h : IsUnit v
state_before: l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: have := isUnit_diagonal.mpr h
state_before: case pos
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : IsUnit v
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: cases this.nonempty_invertible
state_before: case pos
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : IsUnit v
this : IsUnit (diagonal v)
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: cases h.nonempty_invertible
state_before: case pos.intro
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : IsUnit v
this : IsUnit (diagonal v)
val✝ : Invertible (diagonal v)
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: rw [Ring.inverse_invertible, Ring.inverse_invertible, invOf_diagonal_eq]
state_before: case pos.intro.intro
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : IsUnit v
this : IsUnit (diagonal v)
val✝¹ : Invertible (diagonal v)
val✝ : Invertible v
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: have := isUnit_diagonal.not.mpr h
state_before: case neg
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : ¬IsUnit v
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

tactic: rw [Ring.inverse_non_unit _ h, Pi.zero_def, diagonal_zero, Ring.inverse_non_unit _ this]
state_before: case neg
l : Type ?u.340020
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : ¬IsUnit v
this : ¬IsUnit (diagonal v)
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)