1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: EMetric.diam_union'
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: let ⟨x, ⟨xs, xt⟩⟩ := h
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t

tactic: simpa using diam_union xs xt
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: no goals
Theorem: Profinite.NobelingProof.isClosed_C1
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: refine hC.inter ?_
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed (C1 C ho)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = true}

tactic: have h : Continuous (fun (f : I → Bool) ↦ f (term I ho)) := continuous_apply (term I ho)
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = true}
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = true}

tactic: exact IsClosed.preimage h (t := {true}) (isClosed_discrete _)
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = true}
state_after: no goals
Theorem: LieSubmodule.trace_eq_trace_restrict_of_le_idealizer
File: Mathlib/Algebra/Lie/TraceForm.lean

tactic: suffices ∀ m, ⁅x, ⁅y, m⁆⁆ ∈ N by simp [(φ x ∘ₗ φ y).trace_restrict_eq_of_forall_mem _ this]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ (trace R M) (φ x ∘ₗ φ y) = (trace R ↥↑N) ((φ x ∘ₗ φ y).restrict hy')
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ ∀ (m : M), ⁅x, ⁅y, m⁆⁆ ∈ N

tactic: exact fun m ↦ N.lie_mem (h hy m)
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ ∀ (m : M), ⁅x, ⁅y, m⁆⁆ ∈ N
state_after: no goals

tactic: simp [(φ x ∘ₗ φ y).trace_restrict_eq_of_forall_mem _ this]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
this : ∀ (m : M), ⁅x, ⁅y, m⁆⁆ ∈ N
⊢ (trace R M) (φ x ∘ₗ φ y) = (trace R ↥↑N) ((φ x ∘ₗ φ y).restrict hy')
state_after: no goals
Theorem: ZMod.val_injective
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
inst✝ : NeZero n
⊢ Injective val
state_after: case zero
inst✝ : NeZero 0
⊢ Injective val

case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Injective val

tactic: intro a b h
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Injective val
state_after: case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ a = b

tactic: ext
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ a = b
state_after: case succ.h
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ ↑a = ↑b

tactic: exact h
state_before: case succ.h
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ ↑a = ↑b
state_after: no goals

tactic: cases NeZero.ne 0 rfl
state_before: case zero
inst✝ : NeZero 0
⊢ Injective val
state_after: no goals
Theorem: Mathlib.Tactic.Ring.mul_pp_pf_overlap
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea eb e : ℕ
a₂ b₂ c x : R
x✝¹ : ea + eb = e
x✝ : a₂ * b₂ = c
⊢ x ^ ea * a₂ * (x ^ eb * b₂) = x ^ e * c
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea eb : ℕ
a₂ b₂ x : R
⊢ x ^ ea * a₂ * (x ^ eb * b₂) = x ^ (ea + eb) * (a₂ * b₂)

tactic: simp [pow_add, mul_mul_mul_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea eb : ℕ
a₂ b₂ x : R
⊢ x ^ ea * a₂ * (x ^ eb * b₂) = x ^ (ea + eb) * (a₂ * b₂)
state_after: no goals
Theorem: CoxeterSystem.wordProd_reverse
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: induction' ω with x ω' ih
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.wordProd ω.reverse = (cs.wordProd ω)⁻¹
state_after: case nil
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.wordProd [].reverse = (cs.wordProd [])⁻¹

case cons
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
x : B
ω' : List B
ih : cs.wordProd ω'.reverse = (cs.wordProd ω')⁻¹
⊢ cs.wordProd (x :: ω').reverse = (cs.wordProd (x :: ω'))⁻¹

tactic: simp
state_before: case nil
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.wordProd [].reverse = (cs.wordProd [])⁻¹
state_after: no goals

tactic: simpa [wordProd_cons, wordProd_append] using ih
state_before: case cons
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
x : B
ω' : List B
ih : cs.wordProd ω'.reverse = (cs.wordProd ω')⁻¹
⊢ cs.wordProd (x :: ω').reverse = (cs.wordProd (x :: ω'))⁻¹
state_after: no goals
Theorem: Multiset.card_powerset
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp
state_before: α : Type u_1
s : Multiset α
⊢ ∀ (a : List α), card (powerset ⟦a⟧) = 2 ^ card ⟦a⟧
state_after: no goals
Theorem: Finset.attach_eq_empty_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
⊢ s.attach = ∅ ↔ s = ∅
state_after: no goals
Theorem: le_iff_uniformContinuous_id
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformContinuous_iff, uniformSpace_comap_id, id]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u v : UniformSpace α
⊢ u ≤ v ↔ UniformContinuous id
state_after: no goals
Theorem: SimpleGraph.dist_comm_aux
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: obtain ⟨p, hp⟩ := h.symm.exists_walk_of_dist
state_before: V : Type u_1
G : SimpleGraph V
u v : V
h : G.Reachable u v
⊢ G.dist u v ≤ G.dist v u
state_after: case intro
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Reachable u v
p : G.Walk v u
hp : p.length = G.dist v u
⊢ G.dist u v ≤ G.dist v u

tactic: rw [← hp, ← Walk.length_reverse]
state_before: case intro
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Reachable u v
p : G.Walk v u
hp : p.length = G.dist v u
⊢ G.dist u v ≤ G.dist v u
state_after: case intro
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Reachable u v
p : G.Walk v u
hp : p.length = G.dist v u
⊢ G.dist u v ≤ p.reverse.length

tactic: apply dist_le
state_before: case intro
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Reachable u v
p : G.Walk v u
hp : p.length = G.dist v u
⊢ G.dist u v ≤ p.reverse.length
state_after: no goals
Theorem: IsAdjoinRoot.lift_self_apply
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [← h.map_repr x, lift_map, ← aeval_def, h.aeval_eq]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
f : R[X]
h : IsAdjoinRoot S f
x : S
⊢ (lift (algebraMap R S) h.root ⋯ h) x = x
state_after: no goals
Theorem: Function.Semiconj.mapsTo_preimage
File: Mathlib/Data/Set/Function.lean

tactic: simp only [mem_preimage, h x, hb hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
fa : α → α
fb : β → β
f : α → β
g : β → γ
s✝ t✝ : Set α
h : Semiconj f fa fb
s t : Set β
hb : MapsTo fb s t
x : α
hx : x ∈ f ⁻¹' s
⊢ fa x ∈ f ⁻¹' t
state_after: no goals
Theorem: ContDiffAt.smul
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → 𝕜
g : E → F
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g x
⊢ ContDiffAt 𝕜 n (fun x => f x • g x) x
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → 𝕜
g : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x • g x) univ x

tactic: exact hf.smul hg
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → 𝕜
g : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x • g x) univ x
state_after: no goals
Theorem: DirectSum.decompose_of_mem_ne
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: rw [decompose_of_mem _ hx, DirectSum.of_eq_of_ne _ _ _ _ hij, ZeroMemClass.coe_zero]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
x : M
i j : ι
hx : x ∈ ℳ i
hij : i ≠ j
⊢ ↑(((decompose ℳ) x) j) = 0
state_after: no goals
Theorem: Multiset.product_singleton
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp only [SProd.sprod, product, bind_singleton, map_singleton]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
b : β
s : Multiset α
t : Multiset β
⊢ {a} ×ˢ {b} = {(a, b)}
state_after: no goals
Theorem: DomMulAct.edist_smul_Lp
File: Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean

tactic: simp only [Lp.edist_dist, dist_smul_Lp]
state_before: M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
f g : ↥(Lp E p μ)
⊢ edist (c • f) (c • g) = edist f g
state_after: no goals
Theorem: Multiset.product_zero
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [SProd.sprod, product]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
b : β
s : Multiset α
t : Multiset β
⊢ s ×ˢ 0 = 0
state_after: no goals
Theorem: Filter.blimsup_congr
File: Mathlib/Order/LiminfLimsup.lean

tactic: simpa only [blimsup_eq_limsup] using limsup_congr <| eventually_inf_principal.2 h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
⊢ blimsup u f p = blimsup v f p
state_after: no goals
Theorem: UpperSet.infIrred_Ici
File: Mathlib/Order/Birkhoff.lean

tactic: refine ⟨fun h ↦ Ici_ne_top h.eq_top, fun s t hst ↦ ?_⟩
state_before: α : Type u_1
inst✝ : PartialOrder α
s : UpperSet α
a : α
⊢ InfIrred (Ici a)
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
⊢ s = Ici a ∨ t = Ici a

tactic: have := mem_Ici_iff.2 (le_refl a)
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
⊢ s = Ici a ∨ t = Ici a
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
this : a ∈ Ici a
⊢ s = Ici a ∨ t = Ici a

tactic: rw [← hst] at this
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
this : a ∈ Ici a
⊢ s = Ici a ∨ t = Ici a
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
this : a ∈ s ⊓ t
⊢ s = Ici a ∨ t = Ici a

tactic: exact this.imp (fun ha ↦ le_antisymm (le_Ici.2 ha) <| hst.ge.trans inf_le_left) fun ha ↦
    le_antisymm (le_Ici.2 ha) <| hst.ge.trans inf_le_right
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : UpperSet α
a : α
s t : UpperSet α
hst : s ⊓ t = Ici a
this : a ∈ s ⊓ t
⊢ s = Ici a ∨ t = Ici a
state_after: no goals
Theorem: InnerProductGeometry.angle_neg_left
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← angle_neg_neg, neg_neg, angle_neg_right]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ angle (-x) y = π - angle x y
state_after: no goals
Theorem: CauSeq.sup_eq_left
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simpa only [CauSeq.sup_comm] using CauSeq.sup_eq_right h
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : b ≤ a
⊢ a ⊔ b ≈ a
state_after: no goals
Theorem: self_mul_sign
File: Mathlib/Data/Sign.lean

tactic: rcases lt_trichotomy x 0 with hx | rfl | hx <;> simp [*, abs_of_pos, abs_of_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b x : α
⊢ x * ↑(sign x) = |x|
state_after: no goals
Theorem: MeasureTheory.withDensityᵥ_apply
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: rw [withDensityᵥ, dif_pos hf]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f μ
s : Set α
hs : MeasurableSet s
⊢ ↑(μ.withDensityᵥ f) s = ∫ (x : α) in s, f x ∂μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f μ
s : Set α
hs : MeasurableSet s
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0, empty' := ⋯, not_measurable' := ⋯,
          m_iUnion' := ⋯ }
      s =
    ∫ (x : α) in s, f x ∂μ

tactic: exact dif_pos hs
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f μ
s : Set α
hs : MeasurableSet s
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0, empty' := ⋯, not_measurable' := ⋯,
          m_iUnion' := ⋯ }
      s =
    ∫ (x : α) in s, f x ∂μ
state_after: no goals
Theorem: AffineEquiv.injective_pointReflection_left_of_module
File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

tactic: rwa [bit0, bit0, ← two_smul k x, ← two_smul k y,
  (isUnit_of_invertible (2 : k)).smul_left_cancel] at h
state_before: k : Type u_1
P₁ : Type u_2
P₂ : Type u_3
P₃ : Type u_4
P₄ : Type u_5
V₁ : Type u_6
V₂ : Type u_7
V₃ : Type u_8
V₄ : Type u_9
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V₁
inst✝¹¹ : Module k V₁
inst✝¹⁰ : AffineSpace V₁ P₁
inst✝⁹ : AddCommGroup V₂
inst✝⁸ : Module k V₂
inst✝⁷ : AffineSpace V₂ P₂
inst✝⁶ : AddCommGroup V₃
inst✝⁵ : Module k V₃
inst✝⁴ : AffineSpace V₃ P₃
inst✝³ : AddCommGroup V₄
inst✝² : Module k V₄
inst✝¹ : AffineSpace V₄ P₄
inst✝ : Invertible 2
x y : V₁
h : bit0 x = bit0 y
⊢ x = y
state_after: no goals
Theorem: Complex.cpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def, ite_mul, boole_mul, mul_ite, mul_boole]
state_before: x y z : ℂ
hx : x ≠ 0
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: x y z : ℂ
hx : x ≠ 0
⊢ (if x = 0 then if y + z = 0 then 1 else 0 else cexp (log x * (y + z))) =
    if x = 0 then
      if z = 0 then if x = 0 then if y = 0 then 1 * 1 else 0 * 1 else cexp (log x * y) * 1
      else if x = 0 then if y = 0 then 1 * 0 else 0 * 0 else cexp (log x * y) * 0
    else
      if x = 0 then if y = 0 then 1 * cexp (log x * z) else 0 * cexp (log x * z)
      else cexp (log x * y) * cexp (log x * z)

tactic: simp_all [exp_add, mul_add]
state_before: x y z : ℂ
hx : x ≠ 0
⊢ (if x = 0 then if y + z = 0 then 1 else 0 else cexp (log x * (y + z))) =
    if x = 0 then
      if z = 0 then if x = 0 then if y = 0 then 1 * 1 else 0 * 1 else cexp (log x * y) * 1
      else if x = 0 then if y = 0 then 1 * 0 else 0 * 0 else cexp (log x * y) * 0
    else
      if x = 0 then if y = 0 then 1 * cexp (log x * z) else 0 * cexp (log x * z)
      else cexp (log x * y) * cexp (log x * z)
state_after: no goals
Theorem: Quaternion.coeComplex_add
File: Mathlib/Analysis/Quaternion.lean

tactic: ext <;> simp
state_before: z w : ℂ
⊢ ↑(z + w) = ↑z + ↑w
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isoRestrict_inv_ofRestrict
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: rw [Iso.inv_comp_eq, isoRestrict_hom_ofRestrict]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
⊢ (isoRestrict f).inv ≫ f = Y.ofRestrict ⋯
state_after: no goals
Theorem: isClosed_setOf_clusterPt
File: Mathlib/Topology/Basic.lean

tactic: simp only [ClusterPt, inf_neBot_iff_frequently_left, setOf_forall, imp_iff_not_or]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
⊢ IsClosed {x | ClusterPt x f}
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
⊢ IsClosed (⋂ i, {x | (¬∀ᶠ (x : X) in 𝓝 x, i x) ∨ ∃ᶠ (x : X) in f, i x})

tactic: refine isClosed_iInter fun p => IsClosed.union ?_ ?_ <;> apply isClosed_compl_iff.2
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
⊢ IsClosed (⋂ i, {x | (¬∀ᶠ (x : X) in 𝓝 x, i x) ∨ ∃ᶠ (x : X) in f, i x})
state_after: case refine_1
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
p : X → Prop
⊢ IsOpen fun x => (𝓝 x).sets {x | (fun x => p x) x}

case refine_2
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
p : X → Prop
⊢ IsOpen fun x => f.sets {x | (fun x => ¬(fun x => p x) x) x}

tactic: exacts [isOpen_setOf_eventually_nhds, isOpen_const]
state_before: case refine_1
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
p : X → Prop
⊢ IsOpen fun x => (𝓝 x).sets {x | (fun x => p x) x}

case refine_2
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
p : X → Prop
⊢ IsOpen fun x => f.sets {x | (fun x => ¬(fun x => p x) x) x}
state_after: no goals
Theorem: TopologicalSpace.IsTopologicalBasis.isOpenMap_iff
File: Mathlib/Topology/Bases.lean

tactic: refine ⟨fun H o ho => H _ (hB.isOpen ho), fun hf o ho => ?_⟩
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
⊢ IsOpenMap f ↔ ∀ s ∈ B, IsOpen (f '' s)
state_after: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ s ∈ B, IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (f '' o)

tactic: rw [hB.open_eq_sUnion' ho, sUnion_eq_iUnion, image_iUnion]
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ s ∈ B, IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (f '' o)
state_after: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ s ∈ B, IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (⋃ i, f '' ↑i)

tactic: exact isOpen_iUnion fun s => hf s s.2.1
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ s ∈ B, IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (⋃ i, f '' ↑i)
state_after: no goals