1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Asymptotics.IsBigOWith.pow
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa using h.pow' 0
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝⁴ : SeminormedAddGroup E'''
inst✝³ : SeminormedRing R'
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : NormedDivisionRing 𝕜'
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 α
inst✝ : NormOneClass R
f : α → R
g : α → 𝕜
h : IsBigOWith c l f g
⊢ IsBigOWith (c ^ 0) l (fun x => f x ^ 0) fun x => g x ^ 0
state_after: no goals
Theorem: Finsupp.lapply_comp_lsingle_of_ne
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
a a' : α
h : a ≠ a'
⊢ lapply a ∘ₗ lsingle a' = 0
state_after: case h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
a a' : α
h : a ≠ a'
x✝ : M
⊢ (lapply a ∘ₗ lsingle a') x✝ = 0 x✝

tactic: simp [h.symm]
state_before: case h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
a a' : α
h : a ≠ a'
x✝ : M
⊢ (lapply a ∘ₗ lsingle a') x✝ = 0 x✝
state_after: no goals
Theorem: Nat.recDiagAux_zero_right
File: .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean

tactic: cases m
state_before: motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
h : autoParam (zero_left 0 = zero_right 0) _auto✝
⊢ Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m
state_after: case zero
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
⊢ Nat.recDiagAux zero_left zero_right succ_succ 0 0 = zero_right 0

case succ
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
n✝ : Nat
⊢ Nat.recDiagAux zero_left zero_right succ_succ (n✝ + 1) 0 = zero_right (n✝ + 1)

tactic: exact h
state_before: case zero
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
⊢ Nat.recDiagAux zero_left zero_right succ_succ 0 0 = zero_right 0

case succ
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
n✝ : Nat
⊢ Nat.recDiagAux zero_left zero_right succ_succ (n✝ + 1) 0 = zero_right (n✝ + 1)
state_after: case succ
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
n✝ : Nat
⊢ Nat.recDiagAux zero_left zero_right succ_succ (n✝ + 1) 0 = zero_right (n✝ + 1)

tactic: rfl
state_before: case succ
motive : Nat → Nat → Sort u_1
zero_left : (n : Nat) → motive 0 n
zero_right : (m : Nat) → motive m 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
h : autoParam (zero_left 0 = zero_right 0) _auto✝
n✝ : Nat
⊢ Nat.recDiagAux zero_left zero_right succ_succ (n✝ + 1) 0 = zero_right (n✝ + 1)
state_after: no goals
Theorem: Matrix.eq_zero_of_forall_index_sum_mul_pow_eq_zero
File: Mathlib/LinearAlgebra/Vandermonde.lean

tactic: apply eq_zero_of_forall_index_sum_pow_mul_eq_zero hf
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ v = 0
state_after: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ i : Fin n, f j ^ ↑i * v i = 0

tactic: simp_rw [mul_comm]
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ i : Fin n, f j ^ ↑i * v i = 0
state_after: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ x : Fin n, v x * f j ^ ↑x = 0

tactic: exact hfv
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ x : Fin n, v x * f j ^ ↑x = 0
state_after: no goals
Theorem: CategoryTheory.Limits.colimitHomIsoLimitYoneda'_inv_comp_π
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

tactic: rw [← colimitHomIsoLimitYoneda'_hom_comp_π, ← Category.assoc,
  Iso.inv_hom_id, Category.id_comp]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : Iᵒᵖ ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape I (Type u₂)
A : C
i : I
⊢ (colimitHomIsoLimitYoneda' F A).inv ≫ (coyoneda.map (colimit.ι F { unop := i }).op).app A =
    limit.π (F.rightOp ⋙ yoneda.obj A) i
state_after: no goals
Theorem: Set.range_sigmaMk
File: Mathlib/Data/Set/Sigma.lean

tactic: apply Subset.antisymm
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ range (Sigma.mk i) = Sigma.fst ⁻¹' {i}
state_after: case h₁
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ range (Sigma.mk i) ⊆ Sigma.fst ⁻¹' {i}

case h₂
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ Sigma.fst ⁻¹' {i} ⊆ range (Sigma.mk i)

tactic: rintro _ ⟨b, rfl⟩
state_before: case h₁
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ range (Sigma.mk i) ⊆ Sigma.fst ⁻¹' {i}
state_after: case h₁.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
b : α i
⊢ ⟨i, b⟩ ∈ Sigma.fst ⁻¹' {i}

tactic: simp
state_before: case h₁.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
b : α i
⊢ ⟨i, b⟩ ∈ Sigma.fst ⁻¹' {i}
state_after: no goals

tactic: rintro ⟨x, y⟩ (rfl | _)
state_before: case h₂
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ Sigma.fst ⁻¹' {i} ⊆ range (Sigma.mk i)
state_after: case h₂.mk.refl
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : ι
y : α x
⊢ ⟨x, y⟩ ∈ range (Sigma.mk ⟨x, y⟩.fst)

tactic: exact mem_range_self y
state_before: case h₂.mk.refl
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : ι
y : α x
⊢ ⟨x, y⟩ ∈ range (Sigma.mk ⟨x, y⟩.fst)
state_after: no goals
Theorem: SimpleGraph.Walk.support_concat
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, concat_nil]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
h : G.Adj v w
⊢ (p.concat h).support = p.support.concat w
state_after: no goals
Theorem: Filter.isUnit_iff_singleton
File: Mathlib/Order/Filter/Pointwise.lean

tactic: simp only [isUnit_iff, Group.isUnit, and_true_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
⊢ IsUnit f ↔ ∃ a, f = pure a
state_after: no goals
Theorem: Disjoint.le_symmDiff_sup_symmDiff_right
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [symmDiff_comm a]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ a ∆ b ⊔ a ∆ c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ b ∆ a ⊔ c ∆ a

tactic: exact h.le_symmDiff_sup_symmDiff_left
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ b ∆ a ⊔ c ∆ a
state_after: no goals
Theorem: Mon_.mul_assoc_flip
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ M.X ◁ M.mul ≫ M.mul = (α_ M.X M.X M.X).inv ≫ M.mul ▷ M.X ≫ M.mul
state_after: no goals
Theorem: extChartAt_source_mem_nhds'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← extChartAt_source I]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x x' : M
h : x' ∈ (extChartAt I x).source
⊢ x' ∈ (chartAt H x).source
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isInt_ratCast
File: Mathlib/Tactic/NormNum/Inv.lean

tactic: simp
state_before: R : Type u_1
inst✝ : DivisionRing R
n✝ : ℤ
⊢ ↑↑n✝ = ↑n✝
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.full_univ
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: ext
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
D : Set C
⊢ full univ = ⊤
state_after: case arrows.h.h.h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
D : Set C
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
⊢ x✝ ∈ (full univ).arrows x✝² x✝¹ ↔ x✝ ∈ ⊤.arrows x✝² x✝¹

tactic: simp only [mem_full_iff, mem_univ, and_self, mem_top]
state_before: case arrows.h.h.h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
D : Set C
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
⊢ x✝ ∈ (full univ).arrows x✝² x✝¹ ↔ x✝ ∈ ⊤.arrows x✝² x✝¹
state_after: no goals
Theorem: Option.pmap_bind
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [pmap, bind_eq_bind, none_bind, some_bind]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
δ : Type u_4
p✝ : α✝ → Prop
f✝ : (a : α✝) → p✝ a → β✝
x✝ : Option α✝
α β γ : Type u_5
x : Option α
g : α → Option β
p : β → Prop
f : (b : β) → p b → γ
H : ∀ (a : β), a ∈ x >>= g → p a
H' : ∀ (a : α) (b : β), b ∈ g a → b ∈ x >>= g
⊢ pmap f (x >>= g) H = do
    let a ← x
    pmap f (g a) ⋯
state_after: no goals
Theorem: Nat.sum_append
File: .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean

tactic: induction l₁ <;> simp [*, Nat.add_assoc]
state_before: l₁ l₂ : List Nat
⊢ Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂
state_after: no goals
Theorem: HasDerivWithinAt.complexToReal_fderiv'
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [Complex.restrictScalars_one_smulRight'] using
  h.hasFDerivWithinAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
s : Set ℂ
x : ℂ
f' : E
h : HasDerivWithinAt f f' s x
⊢ HasFDerivWithinAt f (reCLM.smulRight f' + I • imCLM.smulRight f') s x
state_after: no goals
Theorem: FiberPrebundle.isOpen_source
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: refine isOpen_iSup_iff.mpr fun e' => isOpen_iSup_iff.mpr fun _ => ?_
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e : Pretrivialization F TotalSpace.proj
⊢ IsOpen e.source
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
⊢ IsOpen e.source

tactic: refine isOpen_coinduced.mpr (isOpen_induced_iff.mpr ⟨e.target, e.open_target, ?_⟩)
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
⊢ IsOpen e.source
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
⊢ Subtype.val ⁻¹' e.target = e'.setSymm ⁻¹' e.source

tactic: ext ⟨x, hx⟩
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
⊢ Subtype.val ⁻¹' e.target = e'.setSymm ⁻¹' e.source
state_after: case h.mk
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
x : B × F
hx : x ∈ e'.target
⊢ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' e.target ↔ ⟨x, hx⟩ ∈ e'.setSymm ⁻¹' e.source

tactic: simp only [mem_preimage, Pretrivialization.setSymm, restrict, e.mem_target, e.mem_source,
  e'.proj_symm_apply hx]
state_before: case h.mk
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ e e' : Pretrivialization F TotalSpace.proj
x✝ : e' ∈ a.pretrivializationAtlas
x : B × F
hx : x ∈ e'.target
⊢ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' e.target ↔ ⟨x, hx⟩ ∈ e'.setSymm ⁻¹' e.source
state_after: no goals
Theorem: isLowerSet_compl
File: Mathlib/Order/UpperLower/Basic.lean

tactic: convert h.compl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ IsUpperSet s
state_after: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ s = sᶜᶜ

tactic: rw [compl_compl]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ s = sᶜᶜ
state_after: no goals
Theorem: Stream'.append_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rw [List.cons_append, cons_append_stream, cons_append_stream, append_append_stream l₁]
state_before: α : Type u
β : Type v
δ : Type w
a : α
l₁ l₂ : List α
s : Stream' α
⊢ a :: l₁ ++ l₂ ++ₛ s = a :: l₁ ++ₛ (l₂ ++ₛ s)
state_after: no goals
Theorem: CategoryTheory.isCodetecting_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [← isDetecting_op_iff, Set.unop_op]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set Cᵒᵖ
⊢ IsCodetecting 𝒢.unop ↔ IsDetecting 𝒢
state_after: no goals
Theorem: PartENat.withTopEquiv_symm_le
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp
state_before: x y : ℕ∞
⊢ withTopEquiv.symm x ≤ withTopEquiv.symm y ↔ x ≤ y
state_after: no goals
Theorem: fourierSubalgebra_coe
File: Mathlib/Analysis/Fourier/AddCircle.lean

tactic: apply adjoin_eq_span_of_subset
state_before: T : ℝ
⊢ Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = span ℂ (range fourier)
state_after: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ ↑(span ℂ (range fourier))

tactic: refine Subset.trans ?_ Submodule.subset_span
state_before: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ ↑(span ℂ (range fourier))
state_after: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ range fourier

tactic: intro x hx
state_before: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ range fourier
state_after: case hs
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ x ∈ range fourier

tactic: refine Submonoid.closure_induction hx (fun _ => id) ⟨0, ?_⟩ ?_
state_before: case hs
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ x ∈ range fourier
state_after: case hs.refine_1
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ fourier 0 = 1

case hs.refine_2
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ ∀ (x y : C(AddCircle T, ℂ)), x ∈ range fourier → y ∈ range fourier → x * y ∈ range fourier

tactic: ext1 z
state_before: case hs.refine_1
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ fourier 0 = 1
state_after: case hs.refine_1.h
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
z : AddCircle T
⊢ (fourier 0) z = 1 z

tactic: exact fourier_zero
state_before: case hs.refine_1.h
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
z : AddCircle T
⊢ (fourier 0) z = 1 z
state_after: no goals

tactic: rintro _ _ ⟨m, rfl⟩ ⟨n, rfl⟩
state_before: case hs.refine_2
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ ∀ (x y : C(AddCircle T, ℂ)), x ∈ range fourier → y ∈ range fourier → x * y ∈ range fourier
state_after: case hs.refine_2.intro.intro
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
⊢ fourier m * fourier n ∈ range fourier

tactic: refine ⟨m + n, ?_⟩
state_before: case hs.refine_2.intro.intro
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
⊢ fourier m * fourier n ∈ range fourier
state_after: case hs.refine_2.intro.intro
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
⊢ fourier (m + n) = fourier m * fourier n

tactic: ext1 z
state_before: case hs.refine_2.intro.intro
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
⊢ fourier (m + n) = fourier m * fourier n
state_after: case hs.refine_2.intro.intro.h
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
z : AddCircle T
⊢ (fourier (m + n)) z = (fourier m * fourier n) z

tactic: exact fourier_add
state_before: case hs.refine_2.intro.intro.h
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
m n : ℤ
z : AddCircle T
⊢ (fourier (m + n)) z = (fourier m * fourier n) z
state_after: no goals
Theorem: ZMod.min_le_card_add
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

tactic: simpa only [ZMod.minOrder_of_prime hp, min_le_iff, Nat.cast_le] using Finset.min_le_card_add hs ht
state_before: α : Type u_1
p : ℕ
hp : Nat.Prime p
s t : Finset (ZMod p)
hs : s.Nonempty
ht : t.Nonempty
⊢ min p (s.card + t.card - 1) ≤ (s + t).card
state_after: no goals
Theorem: Metric.glueDist_triangle_inl_inr_inr
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: simp only [glueDist]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
⊢ glueDist Φ Ψ ε (Sum.inl x) (Sum.inr z) ≤
    glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) + glueDist Φ Ψ ε (Sum.inr y) (Sum.inr z)
state_after: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
⊢ (⨅ p, dist x (Φ p) + dist z (Ψ p)) + ε ≤ (⨅ p, dist x (Φ p) + dist y (Ψ p)) + ε + dist y z

tactic: rw [add_right_comm, add_le_add_iff_right]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
⊢ (⨅ p, dist x (Φ p) + dist z (Ψ p)) + ε ≤ (⨅ p, dist x (Φ p) + dist y (Ψ p)) + ε + dist y z
state_after: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
⊢ ⨅ p, dist x (Φ p) + dist z (Ψ p) ≤ (⨅ p, dist x (Φ p) + dist y (Ψ p)) + dist y z

tactic: refine le_ciInf_add fun p => ciInf_le_of_le ⟨0, ?_⟩ p ?_
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
⊢ ⨅ p, dist x (Φ p) + dist z (Ψ p) ≤ (⨅ p, dist x (Φ p) + dist y (Ψ p)) + dist y z
state_after: case refine_1
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
p : Z
⊢ 0 ∈ lowerBounds (range fun p => dist x (Φ p) + dist z (Ψ p))

case refine_2
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
p : Z
⊢ dist x (Φ p) + dist z (Ψ p) ≤ dist x (Φ p) + dist y (Ψ p) + dist y z

tactic: exact forall_mem_range.2 fun _ => add_nonneg dist_nonneg dist_nonneg
state_before: case refine_1
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
p : Z
⊢ 0 ∈ lowerBounds (range fun p => dist x (Φ p) + dist z (Ψ p))
state_after: no goals

tactic: linarith [dist_triangle_left z (Ψ p) y]
state_before: case refine_2
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : X
y z : Y
p : Z
⊢ dist x (Φ p) + dist z (Ψ p) ≤ dist x (Φ p) + dist y (Ψ p) + dist y z
state_after: no goals