tasksource/leandojo huggingface dataset:
Theorem: CommRingCat.Colimits.cocone_naturality_components
File: Mathlib/Algebra/Category/Ring/Colimits.lean

tactic: rw [← cocone_naturality F f]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommRingCat
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ ↑(coconeMorphism F j') (↑(F.map f) x) = ↑(coconeMorphism F j) x

tactic: rfl
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommRingCat
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ ↑(coconeMorphism F j') (↑(F.map f) x) = ↑(F.map f ≫ coconeMorphism F j') x
Theorem: ContinuousLinearMap.hasFPowerSeriesOnBall
File: Mathlib/Analysis/Analytic/Linear.lean

tactic: simp
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.16649
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F
x : E
⊢ ⊤ ≤ FormalMultilinearSeries.radius (fpowerSeries f x)

tactic: simp [Finset.sum_range_succ, ← sub_sub, hasSum_zero, fpowerSeries]
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.16649
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F
x y✝ : E
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => ↑(fpowerSeries f x (n + 2)) fun x => y✝)
    (↑f (x + y✝) - ∑ i in Finset.range 2, ↑(fpowerSeries f x i) fun x => y✝)
Theorem: CategoryTheory.NonPreadditiveAbelian.σ_comp
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: obtain ⟨g, hg⟩ :=
  CokernelCofork.IsColimit.desc' isColimitσ (Limits.prod.map f f ≫ σ) (by
    rw [prod.diag_map_assoc, diag_σ, comp_zero])
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
⊢ σ ≫ f = prod.map f f ≫ σ

tactic: suffices hfg : f = g
state_before: case mk
C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ σ ≫ f = prod.map f f ≫ σ

tactic: calc
  f = f ≫ prod.lift (𝟙 Y) 0 ≫ σ := by rw [lift_σ, Category.comp_id]
  _ = prod.lift (𝟙 X) 0 ≫ Limits.prod.map f f ≫ σ := by rw [lift_map_assoc]
  _ = prod.lift (𝟙 X) 0 ≫ σ ≫ g := by rw [← hg, CokernelCofork.π_ofπ]
  _ = g := by rw [← Category.assoc, lift_σ, Category.id_comp]
state_before: case hfg
C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ f = g

tactic: rw [prod.diag_map_assoc, diag_σ, comp_zero]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
⊢ diag X ≫ prod.map f f ≫ σ = 0

tactic: rw [← hg, Cofork.π_ofπ, hfg]
state_before: case mk
C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
hfg : f = g
⊢ σ ≫ f = prod.map f f ≫ σ

tactic: rw [lift_σ, Category.comp_id]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ f = f ≫ prod.lift (𝟙 Y) 0 ≫ σ

tactic: rw [lift_map_assoc]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ f ≫ prod.lift (𝟙 Y) 0 ≫ σ = prod.lift (𝟙 X) 0 ≫ prod.map f f ≫ σ

tactic: rw [← hg, CokernelCofork.π_ofπ]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ prod.lift (𝟙 X) 0 ≫ prod.map f f ≫ σ = prod.lift (𝟙 X) 0 ≫ σ ≫ g

tactic: rw [← Category.assoc, lift_σ, Category.id_comp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ (_ : diag X ≫ σ = 0)) ≫ g = prod.map f f ≫ σ
⊢ prod.lift (𝟙 X) 0 ≫ σ ≫ g = g
Theorem: smul_eq_self_of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp hx
state_before: G : Type u
A : Type v
x y : G
a✝ b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
i : ℤ
α : Type u_1
inst✝ : MulAction G α
hx : x ∈ Subgroup.zpowers y
a : α
hs : y • a = a
⊢ x • a = a

tactic: rw [← MulAction.toPerm_apply, ← MulAction.toPermHom_apply, MonoidHom.map_zpow _ y k,
  MulAction.toPermHom_apply]
state_before: case intro
G : Type u
A : Type v
y : G
a✝ b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
i : ℤ
α : Type u_1
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ Subgroup.zpowers y
⊢ y ^ k • a = a

tactic: exact Function.IsFixedPt.perm_zpow (by exact hs) k
state_before: case intro
G : Type u
A : Type v
y : G
a✝ b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
i : ℤ
α : Type u_1
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ Subgroup.zpowers y
⊢ ↑(MulAction.toPerm y ^ k) a = a

tactic: exact hs
state_before: G : Type u
A : Type v
y : G
a✝ b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
i : ℤ
α : Type u_1
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ Subgroup.zpowers y
⊢ IsFixedPt (↑(MulAction.toPerm y)) a
Theorem: Setoid.sInf_def
File: Mathlib/Data/Setoid/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.2669
s : Set (Setoid α)
⊢ Rel (sInf s) = sInf (Rel '' s)

tactic: simp only [sInf_image, iInf_apply, iInf_Prop_eq]
state_before: case h.h.a
α : Type u_1
β : Type ?u.2669
s : Set (Setoid α)
x✝¹ x✝ : α
⊢ Rel (sInf s) x✝¹ x✝ ↔ sInf (Rel '' s) x✝¹ x✝

tactic: rfl
state_before: case h.h.a
α : Type u_1
β : Type ?u.2669
s : Set (Setoid α)
x✝¹ x✝ : α
⊢ Rel (sInf s) x✝¹ x✝ ↔ ∀ (i : Setoid α), i ∈ s → Rel i x✝¹ x✝
Theorem: List.Sublist.filter
File: Std/Data/List/Lemmas.lean

tactic: rw [← filterMap_eq_filter]
state_before: α : Type u_1
p : α → Bool
l₁ l₂ : List α
s : l₁ <+ l₂
⊢ List.filter p l₁ <+ List.filter p l₂

tactic: apply s.filterMap
state_before: α : Type u_1
p : α → Bool
l₁ l₂ : List α
s : l₁ <+ l₂
⊢ List.filterMap (Option.guard fun x => p x = true) l₁ <+ List.filterMap (Option.guard fun x => p x = true) l₂
Theorem: Polynomial.mem_lifts_iff_mem_alg
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, lifts, mapAlg_eq_map, AlgHom.mem_range, RingHom.mem_rangeS]
state_before: R✝ : Type u
inst✝⁵ : CommSemiring R✝
S✝ : Type v
inst✝⁴ : Semiring S✝
inst✝³ : Algebra R✝ S✝
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : Semiring S
inst✝ : Algebra R S
p : S[X]
⊢ p ∈ lifts (algebraMap R S) ↔ p ∈ AlgHom.range (mapAlg R S)
Theorem: Multiset.range_add_eq_union
File: Mathlib/Data/Multiset/Range.lean

tactic: rw [range_add, add_eq_union_iff_disjoint]
state_before: a b : ℕ
⊢ range (a + b) = range a ∪ map (fun x => a + x) (range b)

tactic: apply range_disjoint_map_add
state_before: a b : ℕ
⊢ Disjoint (range a) (map (fun x => a + x) (range b))
Theorem: Sum.isLeft_map
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
f : α → β
g : γ → δ
x : α ⊕ γ
⊢ isLeft (Sum.map f g x) = isLeft x
Theorem: MeasureTheory.SimpleFunc.approxOn_mem
File: Mathlib/MeasureTheory/Function/SimpleFuncDense.lean

tactic: haveI : Nonempty s := ⟨⟨y₀, h₀⟩⟩
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n : ℕ
x : β
⊢ ↑(approxOn f hf s y₀ h₀ n) x ∈ s

tactic: suffices ∀ n, (Nat.casesOn n y₀ ((↑) ∘ denseSeq s) : α) ∈ s by apply this
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n : ℕ
x : β
this : Nonempty ↑s
⊢ ↑(approxOn f hf s y₀ h₀ n) x ∈ s

tactic: rintro (_ | n)
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n : ℕ
x : β
this : Nonempty ↑s
⊢ ∀ (n : ℕ), Nat.casesOn n y₀ (Subtype.val ∘ denseSeq ↑s) ∈ s

tactic: exacts [h₀, Subtype.mem _]
state_before: case zero
α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n : ℕ
x : β
this : Nonempty ↑s
⊢ Nat.casesOn Nat.zero y₀ (Subtype.val ∘ denseSeq ↑s) ∈ s

case succ
α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n✝ : ℕ
x : β
this : Nonempty ↑s
n : ℕ
⊢ Nat.casesOn (Nat.succ n) y₀ (Subtype.val ∘ denseSeq ↑s) ∈ s

tactic: apply this
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.57259
E : Type ?u.57262
F : Type ?u.57265
𝕜 : Type ?u.57268
inst✝⁴ : MeasurableSpace α
inst✝³ : PseudoEMetricSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : MeasurableSpace β
f✝ f : β → α
hf : Measurable f
s : Set α
y₀ : α
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
n : ℕ
x : β
this✝ : Nonempty ↑s
this : ∀ (n : ℕ), Nat.casesOn n y₀ (Subtype.val ∘ denseSeq ↑s) ∈ s
⊢ ↑(approxOn f hf s y₀ h₀ n) x ∈ s
Theorem: Localization.mulEquivOfQuotient_symm_mk
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mk_eq_monoidOf_mk'_apply]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.3298538
inst✝ : CommMonoid P
f : Submonoid.LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ ↑(MulEquiv.symm (mulEquivOfQuotient f)) (Submonoid.LocalizationMap.mk' f x y) = mk x y

tactic: exact mulEquivOfQuotient_symm_mk' _ _
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.3298538
inst✝ : CommMonoid P
f : Submonoid.LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ ↑(MulEquiv.symm (mulEquivOfQuotient f)) (Submonoid.LocalizationMap.mk' f x y) =
    Submonoid.LocalizationMap.mk' (monoidOf S) x y
Theorem: induced_topology_pure
File: Mathlib/Topology/StoneCech.lean

tactic: apply eq_bot_of_singletons_open
state_before: α : Type u
⊢ induced pure Ultrafilter.topologicalSpace = ⊥

tactic: intro x
state_before: case h
α : Type u
⊢ ∀ (x : α), IsOpen {x}

tactic: use { u : Ultrafilter α | {x} ∈ u }, ultrafilter_isOpen_basic _
state_before: case h
α : Type u
x : α
⊢ IsOpen {x}

tactic: simp
state_before: case h
α : Type u
x : α
⊢ pure ⁻¹' {u | {x} ∈ u} = {x}
Theorem: left_le_lineMap_iff_le
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rw [lineMap_apply_zero]
state_before: k : Type u_1
E : Type u_2
PE : Type ?u.93916
inst✝³ : LinearOrderedField k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a b : E
r r' : k
h : 0 < r
⊢ a ≤ ↑(lineMap a b) r ↔ ↑(lineMap a b) 0 ≤ ↑(lineMap a b) r
Theorem: WellFounded.eq_strictMono_iff_eq_range_aux
File: Mathlib/Order/WellFounded.lean

tactic: obtain ⟨c, hc⟩ : g b ∈ Set.range f := by
  rw [hfg]
  exact Set.mem_range_self b
state_before: α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
⊢ f b ≤ g b

tactic: cases' lt_or_le c b with hcb hbc
state_before: case intro
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : f c = g b
⊢ f b ≤ g b

tactic: rw [hfg]
state_before: α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
⊢ g b ∈ range f

tactic: exact Set.mem_range_self b
state_before: α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
⊢ g b ∈ range g

tactic: rw [H c hcb] at hc
state_before: case intro.inl
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : f c = g b
hcb : c < b
⊢ f b ≤ g b

tactic: rw [hg.injective hc] at hcb
state_before: case intro.inl
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : g c = g b
hcb : c < b
⊢ f b ≤ g b

tactic: exact hcb.false.elim
state_before: case intro.inl
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : g c = g b
hcb : b < b
⊢ f b ≤ g b

tactic: rw [← hc]
state_before: case intro.inr
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : f c = g b
hbc : b ≤ c
⊢ f b ≤ g b

tactic: exact hf.monotone hbc
state_before: case intro.inr
α : Type ?u.3596
β : Type u_1
inst✝¹ : LinearOrder β
h : WellFounded fun x x_1 => x < x_1
γ : Type u_2
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ (a : β), a < b → f a = g a
c : β
hc : f c = g b
hbc : b ≤ c
⊢ f b ≤ f c
Theorem: midpoint_mem_segment
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rw [segment_eq_image_lineMap]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.158410
G : Type ?u.158413
ι : Type ?u.158416
π : ι → Type ?u.158421
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ midpoint 𝕜 x y ∈ [x-[𝕜]y]

tactic: exact ⟨⅟ 2, ⟨invOf_nonneg.mpr zero_le_two, invOf_le_one one_le_two⟩, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.158410
G : Type ?u.158413
ι : Type ?u.158416
π : ι → Type ?u.158421
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ midpoint 𝕜 x y ∈ ↑(AffineMap.lineMap x y) '' Icc 0 1
Theorem: FreeProduct.NeWord.append_prod
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: simp [toWord, prod, Word.prod]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.609541
inst✝ : Monoid N
i j k l : ι
w₁ : NeWord M i j
hne : j ≠ k
w₂ : NeWord M k l
⊢ prod (append w₁ hne w₂) = prod w₁ * prod w₂
Theorem: Bool.xor_coe_iff
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases a <;> cases b <;> exact by decide
state_before: a b : Bool
⊢ xor a b = true ↔ Xor' (a = true) (b = true)

tactic: decide
state_before: ⊢ xor true true = true ↔ Xor' (true = true) (true = true)
Theorem: CategoryTheory.NatIso.naturality_1
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X Y : C
α : F ≅ G
f : X ⟶ Y
⊢ α.inv.app X ≫ F.map f ≫ α.hom.app Y = G.map f
Theorem: CategoryTheory.Bicategory.whiskerRight_iff
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η θ : f ⟶ g
⊢ η ▷ 𝟙 b = θ ▷ 𝟙 b ↔ η = θ
Theorem: tsub_add_cancel_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ b - a + a = b

tactic: exact add_tsub_cancel_of_le h
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a + (b - a) = b
Theorem: CompositionSeries.toList_sorted
File: Mathlib/Order/JordanHolder.lean

tactic: dsimp [toList]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (List.length (toList s))
h : i < j
⊢ List.get (toList s) i < List.get (toList s) j

tactic: rw [List.get_ofFn, List.get_ofFn]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (List.length (toList s))
h : i < j
⊢ List.get (List.ofFn s.series) i < List.get (List.ofFn s.series) j

tactic: exact s.strictMono h
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (List.length (toList s))
h : i < j
⊢ series s (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1)) i) <
    series s (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1)) j)
Theorem: Function.monotone_iterate_of_id_le
File: Mathlib/Order/Iterate.lean

tactic: rw [iterate_succ_apply']
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
h : id ≤ f
n : ℕ
x : α
⊢ (f^[n]) x ≤ (f^[n + 1]) x

tactic: exact h _
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
h : id ≤ f
n : ℕ
x : α
⊢ (f^[n]) x ≤ f ((f^[n]) x)
Theorem: MeasureTheory.integrable_of_integral_eq_one
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: contrapose h
state_before: α : Type u_1
E : Type ?u.883460
F : Type ?u.883463
𝕜 : Type ?u.883466
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
h : (∫ (x : α), f x ∂μ) = 1
⊢ Integrable f

tactic: rw [integral_undef h]
state_before: α : Type u_1
E : Type ?u.883460
F : Type ?u.883463
𝕜 : Type ?u.883466
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
h : ¬Integrable f
⊢ ¬(∫ (x : α), f x ∂μ) = 1

tactic: exact zero_ne_one
state_before: α : Type u_1
E : Type ?u.883460
F : Type ?u.883463
𝕜 : Type ?u.883466
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
h : ¬Integrable f
⊢ ¬0 = 1
Theorem: hnot_sdiff
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← top_sdiff', sdiff_sdiff, sup_idem]
state_before: ι : Type ?u.172372
α : Type u_1
β : Type ?u.172378
inst✝ : CoheytingAlgebra α
a✝ b c a : α
⊢ ￢a \ a = ￢a
Theorem: one_lt_pow'
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rcases Nat.exists_eq_succ_of_ne_zero hk with ⟨l, rfl⟩
state_before: β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
k : ℕ
hk : k ≠ 0
⊢ 1 < a ^ k

tactic: clear hk
state_before: case intro
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
hk : Nat.succ l ≠ 0
⊢ 1 < a ^ Nat.succ l

tactic: induction' l with l IH
state_before: case intro
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
⊢ 1 < a ^ Nat.succ l

tactic: rw [pow_succ]
state_before: case intro.zero
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
⊢ 1 < a ^ Nat.succ Nat.zero

tactic: simpa using ha
state_before: case intro.zero
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
⊢ 1 < a * a ^ Nat.zero

tactic: rw [pow_succ]
state_before: case intro.succ
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
IH : 1 < a ^ Nat.succ l
⊢ 1 < a ^ Nat.succ (Nat.succ l)

tactic: exact one_lt_mul'' ha IH
state_before: case intro.succ
β : Type ?u.30171
A : Type ?u.30174
G : Type ?u.30177
M : Type u_1
R : Type ?u.30183
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
IH : 1 < a ^ Nat.succ l
⊢ 1 < a * a ^ (l + 1)
Theorem: String.Pos.zero_addChar_eq
File: Std/Data/String/Lemmas.lean

tactic: rw [← zero_addChar_byteIdx]
state_before: c : Char
⊢ 0 + c = { byteIdx := csize c }
Theorem: normSq_eq_of_mem_circle
File: Mathlib/Analysis/Complex/Circle.lean

tactic: simp [normSq_eq_abs]
state_before: z : { x // x ∈ circle }
⊢ ↑normSq ↑z = 1
Theorem: Nat.lt_pow_self
File: Mathlib/Data/Nat/Pow.lean

tactic: simp [zero_lt_one]
state_before: p : ℕ
h : 1 < p
⊢ 0 < p ^ 0
Theorem: IsMetricSeparated.finite_iUnion_left_iff
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

tactic: refine' Finite.induction_on hI (by simp) @fun i I _ _ hI => _
state_before: X : Type u_2
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_1
I : Set ι
hI : Set.Finite I
s : ι → Set X
t : Set X
⊢ IsMetricSeparated (⋃ (i : ι) (_ : i ∈ I), s i) t ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated (s i) t

tactic: rw [biUnion_insert, ball_insert_iff, union_left_iff, hI]
state_before: X : Type u_2
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_1
I✝ : Set ι
hI✝ : Set.Finite I✝
s : ι → Set X
t : Set X
i : ι
I : Set ι
x✝¹ : ¬i ∈ I
x✝ : Set.Finite I
hI : IsMetricSeparated (⋃ (i : ι) (_ : i ∈ I), s i) t ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated (s i) t
⊢ IsMetricSeparated (⋃ (i_1 : ι) (_ : i_1 ∈ insert i I), s i_1) t ↔
    ∀ (i_1 : ι), i_1 ∈ insert i I → IsMetricSeparated (s i_1) t

tactic: simp
state_before: X : Type u_2
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_1
I : Set ι
hI : Set.Finite I
s : ι → Set X
t : Set X
⊢ IsMetricSeparated (⋃ (i : ι) (_ : i ∈ ∅), s i) t ↔ ∀ (i : ι), i ∈ ∅ → IsMetricSeparated (s i) t