tasksource/leandojo huggingface dataset:
Theorem: LazyList.append_bind
File: Mathlib/Data/LazyList/Basic.lean

tactic: match xs with
| LazyList.nil => rfl
| LazyList.cons x xs =>
  simp only [append, Thunk.get, LazyList.bind]
  have := append_bind xs.get ys f
  simp only [Thunk.get] at this
  rw [this, append_assoc]
state_before: α : Type u_1
β : Type u_2
xs : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
⊢ LazyList.bind (append xs ys) f = append (LazyList.bind xs f) { fn := fun x => LazyList.bind (Thunk.get ys) f }

tactic: rfl
state_before: α : Type u_1
β : Type u_2
xs : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
⊢ LazyList.bind (append nil ys) f = append (LazyList.bind nil f) { fn := fun x => LazyList.bind (Thunk.get ys) f }

tactic: simp only [append, Thunk.get, LazyList.bind]
state_before: α : Type u_1
β : Type u_2
xs✝ : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
x : α
xs : Thunk (LazyList α)
⊢ LazyList.bind (append (cons x xs) ys) f =
    append (LazyList.bind (cons x xs) f) { fn := fun x => LazyList.bind (Thunk.get ys) f }

tactic: have := append_bind xs.get ys f
state_before: α : Type u_1
β : Type u_2
xs✝ : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
x : α
xs : Thunk (LazyList α)
⊢ append (f x) { fn := fun x => LazyList.bind (append (Thunk.fn xs ()) ys) f } =
    append (append (f x) { fn := fun x => LazyList.bind (Thunk.fn xs ()) f })
      { fn := fun x => LazyList.bind (Thunk.fn ys ()) f }

tactic: simp only [Thunk.get] at this
state_before: α : Type u_1
β : Type u_2
xs✝ : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
x : α
xs : Thunk (LazyList α)
this :
  LazyList.bind (append (Thunk.get xs) ys) f =
    append (LazyList.bind (Thunk.get xs) f) { fn := fun x => LazyList.bind (Thunk.get ys) f }
⊢ append (f x) { fn := fun x => LazyList.bind (append (Thunk.fn xs ()) ys) f } =
    append (append (f x) { fn := fun x => LazyList.bind (Thunk.fn xs ()) f })
      { fn := fun x => LazyList.bind (Thunk.fn ys ()) f }

tactic: rw [this, append_assoc]
state_before: α : Type u_1
β : Type u_2
xs✝ : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
x : α
xs : Thunk (LazyList α)
this :
  LazyList.bind (append (Thunk.fn xs ()) ys) f =
    append (LazyList.bind (Thunk.fn xs ()) f) { fn := fun x => LazyList.bind (Thunk.fn ys ()) f }
⊢ append (f x) { fn := fun x => LazyList.bind (append (Thunk.fn xs ()) ys) f } =
    append (append (f x) { fn := fun x => LazyList.bind (Thunk.fn xs ()) f })
      { fn := fun x => LazyList.bind (Thunk.fn ys ()) f }
Theorem: derivWithin_inter
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin
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 𝕜
ht : t ∈ 𝓝 x
⊢ derivWithin f (s ∩ t) x = derivWithin f s x

tactic: rw [fderivWithin_inter ht]
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 𝕜
ht : t ∈ 𝓝 x
⊢ ↑(fderivWithin 𝕜 f (s ∩ t) x) 1 = ↑(fderivWithin 𝕜 f s x) 1
Theorem: Left.inv_lt_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a⁻¹ < 1 ↔ 1 < a
Theorem: tendsto_inv_nhdsWithin_Ici_inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa only [inv_inv] using @tendsto_inv_nhdsWithin_Ici _ _ _ _ a⁻¹
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto Inv.inv (𝓝[Ici a⁻¹] a⁻¹) (𝓝[Iic a] a)
Theorem: OrderIso.complementedLattice_iff
File: Mathlib/Order/Hom/Basic.lean

tactic: intro
state_before: F : Type ?u.129007
α : Type u_1
β : Type u_2
γ : Type ?u.129016
δ : Type ?u.129019
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
⊢ ComplementedLattice α → ComplementedLattice β

tactic: exact f.complementedLattice
state_before: F : Type ?u.129007
α : Type u_1
β : Type u_2
γ : Type ?u.129016
δ : Type ?u.129019
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice α
⊢ ComplementedLattice β

tactic: intro
state_before: F : Type ?u.129007
α : Type u_1
β : Type u_2
γ : Type ?u.129016
δ : Type ?u.129019
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
⊢ ComplementedLattice β → ComplementedLattice α

tactic: exact f.symm.complementedLattice
state_before: F : Type ?u.129007
α : Type u_1
β : Type u_2
γ : Type ?u.129016
δ : Type ?u.129019
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice β
⊢ ComplementedLattice α
Theorem: Finset.Ioo_filter_lt
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.141256
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ filter (fun x => x < c) (Ioo a b) = Ioo a (min b c)

tactic: simp [and_assoc]
state_before: case a
ι : Type ?u.141256
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝¹ b✝ a b c a✝ : α
⊢ a✝ ∈ filter (fun x => x < c) (Ioo a b) ↔ a✝ ∈ Ioo a (min b c)
Theorem: CategoryTheory.Subobject.le_sSup
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: fapply le_of_comm
state_before: C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ f ≤ sSup s

tactic: refine' eqToHom _ ≫ Sigma.ι _ ⟨equivShrink (Subobject A) f, by simpa [Set.mem_image] using hf⟩
  ≫ factorThruImage _ ≫ (underlyingIso _).inv
state_before: case f
C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ underlying.obj f ⟶ underlying.obj (sSup s)

tactic: exact (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _).symm)
state_before: case f
C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ underlying.obj f =
    underlying.obj
      (↑(equivShrink (Subobject A)).symm
        ↑{ val := ↑(equivShrink (Subobject A)) f,
            property := (_ : ↑(equivShrink (Subobject A)) f ∈ ↑(equivShrink (Subobject A)) '' s) })

tactic: simpa [Set.mem_image] using hf
state_before: C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ ↑(equivShrink (Subobject A)) f ∈ ↑(equivShrink (Subobject A)) '' s

tactic: simp [sSup, smallCoproductDesc]
state_before: case w
C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ (eqToHom
          (_ :
            underlying.obj f =
              underlying.obj
                (↑(equivShrink (Subobject A)).symm
                  ↑{ val := ↑(equivShrink (Subobject A)) f,
                      property := (_ : ↑(equivShrink (Subobject A)) f ∈ ↑(equivShrink (Subobject A)) '' s) })) ≫
        Sigma.ι (fun j => underlying.obj (↑(equivShrink (Subobject A)).symm ↑j))
            { val := ↑(equivShrink (Subobject A)) f,
              property := (_ : ↑(equivShrink (Subobject A)) f ∈ ↑(equivShrink (Subobject A)) '' s) } ≫
          factorThruImage (smallCoproductDesc s) ≫ (underlyingIso (image.ι (smallCoproductDesc s))).inv) ≫
      arrow (sSup s) =
    arrow f
Theorem: PGame.isOption_neg_neg
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [isOption_neg, neg_neg]
state_before: x y : PGame
⊢ IsOption (-x) (-y) ↔ IsOption x y
Theorem: nhds_prod_eq
File: Mathlib/Topology/Constructions.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u
β : Type v
γ : Type ?u.32917
δ : Type ?u.32920
ε : Type ?u.32923
ζ : Type ?u.32926
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
⊢ 𝓝 (a, b) = 𝓝 a ×ˢ 𝓝 b

tactic: rw [Filter.prod, instTopologicalSpaceProd, nhds_inf (t₁ := TopologicalSpace.induced Prod.fst _)
  (t₂ := TopologicalSpace.induced Prod.snd _), nhds_induced, nhds_induced]
state_before: α : Type u
β : Type v
γ : Type ?u.32917
δ : Type ?u.32920
ε : Type ?u.32923
ζ : Type ?u.32926
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
⊢ 𝓝 (a, b) = Filter.prod (𝓝 a) (𝓝 b)
Theorem: induced_to_pi
File: Mathlib/Topology/Constructions.lean

tactic: erw [induced_iInf]
state_before: α : Type u
β : Type v
γ : Type ?u.512017
δ : Type ?u.512020
ε : Type ?u.512023
ζ : Type ?u.512026
ι : Type u_2
π : ι → Type u_3
κ : Type ?u.512037
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f✝ : α → (i : ι) → π i
X : Type u_1
f : X → (i : ι) → π i
⊢ induced f Pi.topologicalSpace = ⨅ (i : ι), induced (fun x => f x i) inferInstance

tactic: simp only [induced_compose]
state_before: α : Type u
β : Type v
γ : Type ?u.512017
δ : Type ?u.512020
ε : Type ?u.512023
ζ : Type ?u.512026
ι : Type u_2
π : ι → Type u_3
κ : Type ?u.512037
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f✝ : α → (i : ι) → π i
X : Type u_1
f : X → (i : ι) → π i
⊢ (⨅ (i : ι), induced f (induced (fun f => f i) ((fun a => inst✝ a) i))) =
    ⨅ (i : ι), induced (fun x => f x i) inferInstance

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type ?u.512017
δ : Type ?u.512020
ε : Type ?u.512023
ζ : Type ?u.512026
ι : Type u_2
π : ι → Type u_3
κ : Type ?u.512037
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f✝ : α → (i : ι) → π i
X : Type u_1
f : X → (i : ι) → π i
⊢ (⨅ (i : ι), induced ((fun f => f i) ∘ f) (inst✝ i)) = ⨅ (i : ι), induced (fun x => f x i) inferInstance
Theorem: PiNat.iUnion_cylinder_update
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: ext y
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
⊢ (⋃ (k : E n), cylinder (update x n k) (n + 1)) = cylinder x n

tactic: simp only [mem_cylinder_iff, mem_iUnion]
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (y ∈ ⋃ (k : E n), cylinder (update x n k) (n + 1)) ↔ y ∈ cylinder x n

tactic: constructor
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∃ i, ∀ (i_1 : ℕ), i_1 < n + 1 → y i_1 = update x n i i_1) ↔ ∀ (i : ℕ), i < n → y i = x i

tactic: rintro ⟨k, hk⟩ i hi
state_before: case h.mp
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∃ i, ∀ (i_1 : ℕ), i_1 < n + 1 → y i_1 = update x n i i_1) → ∀ (i : ℕ), i < n → y i = x i

tactic: simpa [hi.ne] using hk i (Nat.lt_succ_of_lt hi)
state_before: case h.mp.intro
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
k : E n
hk : ∀ (i : ℕ), i < n + 1 → y i = update x n k i
i : ℕ
hi : i < n
⊢ y i = x i

tactic: intro H
state_before: case h.mpr
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∀ (i : ℕ), i < n → y i = x i) → ∃ i, ∀ (i_1 : ℕ), i_1 < n + 1 → y i_1 = update x n i i_1

tactic: refine' ⟨y n, fun i hi => _⟩
state_before: case h.mpr
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
H : ∀ (i : ℕ), i < n → y i = x i
⊢ ∃ i, ∀ (i_1 : ℕ), i_1 < n + 1 → y i_1 = update x n i i_1

tactic: rcases Nat.lt_succ_iff_lt_or_eq.1 hi with (h'i | rfl)
state_before: case h.mpr
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
H : ∀ (i : ℕ), i < n → y i = x i
i : ℕ
hi : i < n + 1
⊢ y i = update x n (y n) i

tactic: simp [H i h'i, h'i.ne]
state_before: case h.mpr.inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
H : ∀ (i : ℕ), i < n → y i = x i
i : ℕ
hi : i < n + 1
h'i : i < n
⊢ y i = update x n (y n) i

tactic: simp
state_before: case h.mpr.inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
i : ℕ
H : ∀ (i_1 : ℕ), i_1 < i → y i_1 = x i_1
hi : i < i + 1
⊢ y i = update x i (y i) i
Theorem: Complex.normSq_add_mul_I
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [← mk_eq_add_mul_I, normSq_mk, sq, sq]
state_before: x y : ℝ
⊢ ↑normSq (↑x + ↑y * I) = x ^ 2 + y ^ 2
Theorem: Seminorm.mem_closedBall_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [mem_closedBall, sub_zero]
state_before: R : Type ?u.818815
R' : Type ?u.818818
𝕜 : Type u_2
𝕜₂ : Type ?u.818824
𝕜₃ : Type ?u.818827
𝕝 : Type ?u.818830
E : Type u_1
E₂ : Type ?u.818836
E₃ : Type ?u.818839
F : Type ?u.818842
G : Type ?u.818845
ι : Type ?u.818848
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x y : E
r : ℝ
⊢ y ∈ closedBall p 0 r ↔ ↑p y ≤ r
Theorem: UniformSpace.Completion.continuous_mul
File: Mathlib/Topology/Algebra/UniformRing.lean

tactic: let m := (AddMonoidHom.mul : α →+ α →+ α).compr₂ toCompl
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
⊢ Continuous fun p => p.fst * p.snd

tactic: have : Continuous fun p : α × α => m p.1 p.2 := by
  apply (continuous_coe α).comp _
  simp only [AddMonoidHom.coe_mul, AddMonoidHom.coe_mulLeft]
  exact _root_.continuous_mul
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
⊢ Continuous fun p => p.fst * p.snd

tactic: have di : DenseInducing (toCompl : α → Completion α) := denseInducing_coe
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
this : Continuous fun p => ↑(↑m p.fst) p.snd
⊢ Continuous fun p => p.fst * p.snd

tactic: convert di.extend_Z_bilin di this
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
this : Continuous fun p => ↑(↑m p.fst) p.snd
di : DenseInducing ↑toCompl
⊢ Continuous fun p => p.fst * p.snd

tactic: apply (continuous_coe α).comp _
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
⊢ Continuous fun p => ↑(↑m p.fst) p.snd

tactic: simp only [AddMonoidHom.coe_mul, AddMonoidHom.coe_mulLeft]
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
⊢ Continuous fun p => ↑(↑AddMonoidHom.mul p.fst) p.snd

tactic: exact _root_.continuous_mul
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.compr₂ AddMonoidHom.mul toCompl
⊢ Continuous fun p => p.fst * p.snd
Theorem: IsBaseChange.lift_eq
File: Mathlib/RingTheory/IsTensorProduct.lean

tactic: have hF : ∀ (s : S) (m : M), h.lift g (s • f m) = s • g m := h.lift_eq _
state_before: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : CommRing R
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module S N
inst✝⁶ : IsScalarTower R S N
f : M →ₗ[R] N
h : IsBaseChange S f
P : Type ?u.200383
Q : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
inst✝³ : AddCommMonoid Q
inst✝² : Module S Q
inst✝¹ : Module R Q
inst✝ : IsScalarTower R S Q
g : M →ₗ[R] Q
x : M
⊢ ↑(lift h g) (↑f x) = ↑g x

tactic: convert hF 1 x <;> rw [one_smul]
state_before: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : CommRing R
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module S N
inst✝⁶ : IsScalarTower R S N
f : M →ₗ[R] N
h : IsBaseChange S f
P : Type ?u.200383
Q : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
inst✝³ : AddCommMonoid Q
inst✝² : Module S Q
inst✝¹ : Module R Q
inst✝ : IsScalarTower R S Q
g : M →ₗ[R] Q
x : M
hF : ∀ (s : S) (m : M), ↑(lift h g) (s • ↑f m) = s • ↑g m
⊢ ↑(lift h g) (↑f x) = ↑g x
Theorem: Action.associator_hom_hom
File: Mathlib/RepresentationTheory/Action.lean

tactic: dsimp [Monoidal.transport_associator]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ (α_ X Y Z).hom.hom = (α_ X.V Y.V Z.V).hom

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) ≫ (α_ X.V Y.V Z.V).hom ≫ (𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) = (α_ X.V Y.V Z.V).hom
Theorem: AntilipschitzWith.to_rightInvOn'
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simpa only [restrict_apply, g_inv x.mem, g_inv y.mem, Subtype.edist_eq, Subtype.coe_mk] using
  hf ⟨g x, g_maps x.mem⟩ ⟨g y, g_maps y.mem⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.8961
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
s : Set α
hf : AntilipschitzWith K (Set.restrict s f)
g : β → α
t : Set β
g_maps : MapsTo g t s
g_inv : RightInvOn g f t
x y : ↑t
⊢ edist (Set.restrict t g x) (Set.restrict t g y) ≤ ↑K * edist x y
Theorem: ENNReal.inv_strictAnti
File: Mathlib/Data/Real/ENNReal.lean

tactic: intro a b h
state_before: α : Type ?u.265925
β : Type ?u.265928
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ StrictAnti Inv.inv

tactic: lift a to ℝ≥0 using h.ne_top
state_before: α : Type ?u.265925
β : Type ?u.265928
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a < b
⊢ b⁻¹ < a⁻¹

tactic: induction b using recTopCoe
state_before: case intro
α : Type ?u.265925
β : Type ?u.265928
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
a : ℝ≥0
h : ↑a < b
⊢ b⁻¹ < (↑a)⁻¹

tactic: rw [coe_lt_coe] at h
state_before: case intro.coe
α : Type ?u.265925
β : Type ?u.265928
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : ↑a < ↑x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case intro.coe
α : Type ?u.265925
β : Type ?u.265928
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: rw [← coe_inv h.ne_bot, ← coe_inv ha, coe_lt_coe]
state_before: case intro.coe.inr
α : Type ?u.265925
β : Type ?u.265928
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: exact NNReal.inv_lt_inv ha h
state_before: case intro.coe.inr
α : Type ?u.265925
β : Type ?u.265928
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ x✝⁻¹ < a⁻¹

tactic: simp
state_before: case intro.top
α : Type ?u.265925
β : Type ?u.265928
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
h : ↑a < ⊤
⊢ ⊤⁻¹ < (↑a)⁻¹

tactic: simp [h]
state_before: case intro.coe.inl
α : Type ?u.265925
β : Type ?u.265928
a b c d : ℝ≥0∞
r p q x✝ : ℝ≥0
h : 0 < x✝
⊢ (↑x✝)⁻¹ < (↑0)⁻¹
Theorem: Asymptotics.isBigO_neg_right
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def]
state_before: α : Type u_1
β : Type ?u.131381
E : Type u_2
F : Type ?u.131387
G : Type ?u.131390
E' : Type ?u.131393
F' : Type u_3
G' : Type ?u.131399
E'' : Type ?u.131402
F'' : Type ?u.131405
G'' : Type ?u.131408
R : Type ?u.131411
R' : Type ?u.131414
𝕜 : Type ?u.131417
𝕜' : Type ?u.131420
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 α
⊢ (f =O[l] fun x => -g' x) ↔ f =O[l] g'

tactic: exact exists_congr fun _ => isBigOWith_neg_right
state_before: α : Type u_1
β : Type ?u.131381
E : Type u_2
F : Type ?u.131387
G : Type ?u.131390
E' : Type ?u.131393
F' : Type u_3
G' : Type ?u.131399
E'' : Type ?u.131402
F'' : Type ?u.131405
G'' : Type ?u.131408
R : Type ?u.131411
R' : Type ?u.131414
𝕜 : Type ?u.131417
𝕜' : Type ?u.131420
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 α
⊢ (∃ c, IsBigOWith c l f fun x => -g' x) ↔ ∃ c, IsBigOWith c l f g'
Theorem: Finset.filter_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.390807
γ : Type ?u.390810
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ filter p (erase s a) = erase (filter p s) a

tactic: simp only [and_assoc, mem_filter, iff_self_iff, mem_erase]
state_before: case a
α : Type u_1
β : Type ?u.390807
γ : Type ?u.390810
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
a : α
s : Finset α
x : α
⊢ x ∈ filter p (erase s a) ↔ x ∈ erase (filter p s) a
Theorem: Real.Angle.sin_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_zero, sin_coe, Real.sin_zero]
state_before: ⊢ sin 0 = 0