tasksource/leandojo huggingface dataset:
Theorem: preimage_mul_ball
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: ext c
state_before: 𝓕 : Type ?u.743408
𝕜 : Type ?u.743411
α : Type ?u.743414
ι : Type ?u.743417
κ : Type ?u.743420
E : Type u_1
F : Type ?u.743426
G : Type ?u.743429
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
⊢ (fun x x_1 => x * x_1) b ⁻¹' ball a r = ball (a / b) r

tactic: simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
state_before: case h
𝓕 : Type ?u.743408
𝕜 : Type ?u.743411
α : Type ?u.743414
ι : Type ?u.743417
κ : Type ?u.743420
E : Type u_1
F : Type ?u.743426
G : Type ?u.743429
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
c : E
⊢ c ∈ (fun x x_1 => x * x_1) b ⁻¹' ball a r ↔ c ∈ ball (a / b) r
Theorem: SpectralMap.coe_comp_continuousMap
File: Mathlib/Topology/Spectral/Hom.lean

tactic: rfl
state_before: F : Type ?u.8928
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.8940
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : SpectralMap β γ
g : SpectralMap α β
⊢ ↑f ∘ ↑g = ↑(ContinuousMap.mk ↑f) ∘ ↑(ContinuousMap.mk ↑g)
Theorem: ProbabilityTheory.kernel.set_lintegral_piecewise
File: Mathlib/Probability/Kernel/Basic.lean

tactic: simp_rw [piecewise_apply]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1469486
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
t : Set β
⊢ (∫⁻ (b : β) in t, g b ∂↑(piecewise hs κ η) a) =
    if a ∈ s then ∫⁻ (b : β) in t, g b ∂↑κ a else ∫⁻ (b : β) in t, g b ∂↑η a

tactic: split_ifs <;> rfl
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1469486
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
t : Set β
⊢ (∫⁻ (b : β) in t, g b ∂if a ∈ s then ↑κ a else ↑η a) =
    if a ∈ s then ∫⁻ (b : β) in t, g b ∂↑κ a else ∫⁻ (b : β) in t, g b ∂↑η a
Theorem: Finsupp.mapDomain_notin_range
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [mapDomain, sum_apply, sum]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.158167
ι : Type ?u.158170
M : Type u_2
M' : Type ?u.158176
N : Type ?u.158179
P : Type ?u.158182
G : Type ?u.158185
H : Type ?u.158188
R : Type ?u.158191
S : Type ?u.158194
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
x : α →₀ M
a : β
h : ¬a ∈ Set.range f
⊢ ↑(mapDomain f x) a = 0

tactic: exact Finset.sum_eq_zero fun a' _ => single_eq_of_ne fun eq => h <| eq ▸ Set.mem_range_self _
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.158167
ι : Type ?u.158170
M : Type u_2
M' : Type ?u.158176
N : Type ?u.158179
P : Type ?u.158182
G : Type ?u.158185
H : Type ?u.158188
R : Type ?u.158191
S : Type ?u.158194
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
x : α →₀ M
a : β
h : ¬a ∈ Set.range f
⊢ ∑ a_1 in x.support, ↑(single (f a_1) (↑x a_1)) a = 0
Theorem: Submonoid.closure_closure_coe_preimage
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: refine' closure_induction' _ (fun g hg => subset_closure hg) _ (fun g₁ g₂ hg₁ hg₂ => _) hx
state_before: M : Type u_1
N : Type ?u.95294
P : Type ?u.95297
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.95318
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := x, property := hx } ∈ closure (Subtype.val ⁻¹' s)

tactic: exact Submonoid.one_mem _
state_before: case refine'_1
M : Type u_1
N : Type ?u.95294
P : Type ?u.95297
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.95318
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := 1, property := (_ : 1 ∈ closure s) } ∈ closure (Subtype.val ⁻¹' s)

tactic: exact Submonoid.mul_mem _
state_before: case refine'_2
M : Type u_1
N : Type ?u.95294
P : Type ?u.95297
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.95318
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
g₁ : M
g₂ : g₁ ∈ closure s
hg₁ : M
hg₂ : hg₁ ∈ closure s
⊢ { val := g₁, property := g₂ } ∈ closure (Subtype.val ⁻¹' s) →
    { val := hg₁, property := hg₂ } ∈ closure (Subtype.val ⁻¹' s) →
      { val := g₁ * hg₁, property := (_ : g₁ * hg₁ ∈ closure s) } ∈ closure (Subtype.val ⁻¹' s)
Theorem: AdjoinRoot.Minpoly.toAdjoin_apply'
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp [← Subalgebra.coe_eq_zero, aeval_subalgebra_coe]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
a : AdjoinRoot (minpoly R x)
⊢ ↑(aeval { val := x, property := (_ : x ∈ adjoin R {x}) }) (minpoly R x) = 0
Theorem: Metric.ediam_univ_eq_top_iff_noncompact
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← not_compactSpace_iff, compactSpace_iff_bounded_univ, bounded_iff_ediam_ne_top,
  Classical.not_not]
state_before: α : Type u
β : Type v
X : Type ?u.534313
ι : Type ?u.534316
inst✝¹ : PseudoMetricSpace α
s : Set α
x y z : α
inst✝ : ProperSpace α
⊢ EMetric.diam univ = ⊤ ↔ NoncompactSpace α
Theorem: DirectSum.coe_mul_apply
File: Mathlib/Algebra/DirectSum/Internal.lean

tactic: rw [mul_eq_sum_support_ghas_mul, Dfinsupp.finset_sum_apply, AddSubmonoidClass.coe_finset_sum]
state_before: ι : Type u_1
σ : Type u_3
S : Type ?u.100155
R : Type u_2
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ↑(↑(r * r') n) =
    ∑ ij in Finset.filter (fun ij => ij.fst + ij.snd = n) (Dfinsupp.support r ×ˢ Dfinsupp.support r'),
      ↑(↑r ij.fst) * ↑(↑r' ij.snd)

tactic: simp_rw [coe_of_apply, apply_ite, ZeroMemClass.coe_zero, ← Finset.sum_filter, SetLike.coe_gMul]
state_before: ι : Type u_1
σ : Type u_3
S : Type ?u.100155
R : Type u_2
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ∑ i in Dfinsupp.support r ×ˢ Dfinsupp.support r',
      ↑(↑(↑(of (fun i => (fun i => { x // x ∈ A i }) i) (i.fst + i.snd)) (GradedMonoid.GMul.mul (↑r i.fst) (↑r' i.snd)))
          n) =
    ∑ ij in Finset.filter (fun ij => ij.fst + ij.snd = n) (Dfinsupp.support r ×ˢ Dfinsupp.support r'),
      ↑(↑r ij.fst) * ↑(↑r' ij.snd)
Theorem: dist_midpoint_left
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm, dist_left_midpoint]
state_before: α : Type ?u.60686
V : Type u_3
P : Type u_1
W : Type ?u.60695
Q : Type ?u.60698
inst✝⁹ : SeminormedAddCommGroup V
inst✝⁸ : PseudoMetricSpace P
inst✝⁷ : NormedAddTorsor V P
inst✝⁶ : NormedAddCommGroup W
inst✝⁵ : MetricSpace Q
inst✝⁴ : NormedAddTorsor W Q
𝕜 : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : Invertible 2
p₁ p₂ : P
⊢ dist (midpoint 𝕜 p₁ p₂) p₁ = ‖2‖⁻¹ * dist p₁ p₂
Theorem: PGame.relabel_moveRight
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp
state_before: x : PGame
xl' xr' : Type u_1
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
j : RightMoves x
⊢ moveRight (relabel el er) (↑er.symm j) = moveRight x j
Theorem: SimpleGraph.Walk.toSubgraph_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, sup_assoc]
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 : Walk G u v
q : Walk G v w
⊢ Walk.toSubgraph (append p q) = Walk.toSubgraph p ⊔ Walk.toSubgraph q
Theorem: MeasureTheory.OuterMeasure.sInf_eq_boundedBy_sInfGen
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' le_antisymm _ _
state_before: α : Type u_1
m : Set (OuterMeasure α)
⊢ sInf m = boundedBy (sInfGen m)

tactic: refine' le_boundedBy.2 fun s => le_iInf₂ fun μ hμ => _
state_before: case refine'_1
α : Type u_1
m : Set (OuterMeasure α)
⊢ sInf m ≤ boundedBy (sInfGen m)

tactic: apply sInf_le hμ
state_before: case refine'_1
α : Type u_1
m : Set (OuterMeasure α)
s : Set α
μ : OuterMeasure α
hμ : μ ∈ m
⊢ ↑(sInf m) s ≤ ↑μ s

tactic: refine' le_sInf _
state_before: case refine'_2
α : Type u_1
m : Set (OuterMeasure α)
⊢ boundedBy (sInfGen m) ≤ sInf m

tactic: intro μ hμ t
state_before: case refine'_2
α : Type u_1
m : Set (OuterMeasure α)
⊢ ∀ (b : OuterMeasure α), b ∈ m → boundedBy (sInfGen m) ≤ b

tactic: refine' le_trans (boundedBy_le t) (iInf₂_le μ hμ)
state_before: case refine'_2
α : Type u_1
m : Set (OuterMeasure α)
μ : OuterMeasure α
hμ : μ ∈ m
t : Set α
⊢ ↑(boundedBy (sInfGen m)) t ≤ ↑μ t
Theorem: Bool.decide_coe
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b
state_before: b : Bool
h : Decidable (b = true)
⊢ decide (b = true) = b

tactic: exact decide_eq_false $ λ j => by cases j
state_before: case false
h : Decidable (false = true)
⊢ decide (false = true) = false

tactic: cases j
state_before: h : Decidable (false = true)
j : false = true
⊢ False

tactic: exact decide_eq_true $ rfl
state_before: case true
h : Decidable (true = true)
⊢ decide (true = true) = true
Theorem: WellFounded.fix_eq_fixC
File: Std/WF.lean

tactic: funext α C r hwf F x
state_before: ⊢ @fix = @WellFounded.fixC

tactic: rw [fix, fixF_eq_fixFC, fixC]
state_before: case h.h.h.h.h.h
α : Sort u_1
C : α → Sort u_2
r : α → α → Prop
hwf : WellFounded r
F : (x : α) → ((y : α) → r y x → C y) → C x
x : α
⊢ fix hwf F x = WellFounded.fixC hwf F x
Theorem: List.mem_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: induction' t with a t IH generalizing s
state_before: α : Type u
β : Type v
γ : Type w
s t : List α
⊢ s ∈ sublists' t ↔ s <+ t

tactic: simp only [sublists'_cons, mem_append, IH, mem_map]
state_before: case cons
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
⊢ s ∈ sublists' (a :: t) ↔ s <+ a :: t

tactic: constructor <;> intro h
state_before: case cons
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
⊢ (s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s) ↔ s <+ a :: t

tactic: rcases h with (h | ⟨s, h, rfl⟩)
state_before: case cons.mp
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s
⊢ s <+ a :: t

case cons.mpr
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ a :: t
⊢ s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s

tactic: simp only [sublists'_nil, mem_singleton]
state_before: case nil
α : Type u
β : Type v
γ : Type w
s✝ s : List α
⊢ s ∈ sublists' [] ↔ s <+ []

tactic: exact ⟨fun h => by rw [h], eq_nil_of_sublist_nil⟩
state_before: case nil
α : Type u
β : Type v
γ : Type w
s✝ s : List α
⊢ s = [] ↔ s <+ []

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s : List α
h : s = []
⊢ s <+ []

tactic: exact sublist_cons_of_sublist _ h
state_before: case cons.mp.inl
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ t
⊢ s <+ a :: t

tactic: exact h.cons_cons _
state_before: case cons.mp.inr.intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ t
⊢ a :: s <+ a :: t

tactic: cases' h with _ _ _ h s _ _ h
state_before: case cons.mpr
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ a :: t
⊢ s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s

tactic: exact Or.inl h
state_before: case cons.mpr.cons
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ t
⊢ s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s

tactic: exact Or.inr ⟨s, h, rfl⟩
state_before: case cons.mpr.cons₂
α : Type u
β : Type v
γ : Type w
s✝ : List α
a : α
t : List α
IH : ∀ {s : List α}, s ∈ sublists' t ↔ s <+ t
s : List α
h : s <+ t
⊢ a :: s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = a :: s
Theorem: Bitvec.bits_toNat_decide
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: simp [bitsToNat_toList]
state_before: n : ℕ
⊢ Bitvec.toNat (decide (n % 2 = 1) ::ᵥ Vector.nil) = n % 2

tactic: unfold bitsToNat addLsb List.foldl
state_before: n : ℕ
⊢ bitsToNat [decide (n % 2 = 1)] = n % 2

tactic: simp [Nat.cond_decide_mod_two, -Bool.cond_decide]
state_before: n : ℕ
⊢ List.foldl (fun r b => r + r + bif b then 1 else 0) (0 + 0 + bif decide (n % 2 = 1) then 1 else 0) [] = n % 2
Theorem: LinearMap.IsAlt.neg
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: have H1 : B (y + x) (y + x) = 0 := self_eq_zero H (y + x)
state_before: R : Type u_1
R₁ : Type u_3
R₂ : Type ?u.184837
R₃ : Type ?u.184840
M : Type ?u.184843
M₁ : Type u_2
M₂ : Type ?u.184849
Mₗ₁ : Type ?u.184852
Mₗ₁' : Type ?u.184855
Mₗ₂ : Type ?u.184858
Mₗ₂' : Type ?u.184861
K : Type ?u.184864
K₁ : Type ?u.184867
K₂ : Type ?u.184870
V : Type ?u.184873
V₁ : Type ?u.184876
V₂ : Type ?u.184879
n : Type ?u.184882
inst✝³ : CommRing R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H : IsAlt B
x y : M₁
⊢ -↑(↑B x) y = ↑(↑B y) x

tactic: simp [map_add, self_eq_zero H] at H1
state_before: R : Type u_1
R₁ : Type u_3
R₂ : Type ?u.184837
R₃ : Type ?u.184840
M : Type ?u.184843
M₁ : Type u_2
M₂ : Type ?u.184849
Mₗ₁ : Type ?u.184852
Mₗ₁' : Type ?u.184855
Mₗ₂ : Type ?u.184858
Mₗ₂' : Type ?u.184861
K : Type ?u.184864
K₁ : Type ?u.184867
K₂ : Type ?u.184870
V : Type ?u.184873
V₁ : Type ?u.184876
V₂ : Type ?u.184879
n : Type ?u.184882
inst✝³ : CommRing R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H : IsAlt B
x y : M₁
H1 : ↑(↑B (y + x)) (y + x) = 0
⊢ -↑(↑B x) y = ↑(↑B y) x

tactic: rw [add_eq_zero_iff_neg_eq] at H1
state_before: R : Type u_1
R₁ : Type u_3
R₂ : Type ?u.184837
R₃ : Type ?u.184840
M : Type ?u.184843
M₁ : Type u_2
M₂ : Type ?u.184849
Mₗ₁ : Type ?u.184852
Mₗ₁' : Type ?u.184855
Mₗ₂ : Type ?u.184858
Mₗ₂' : Type ?u.184861
K : Type ?u.184864
K₁ : Type ?u.184867
K₂ : Type ?u.184870
V : Type ?u.184873
V₁ : Type ?u.184876
V₂ : Type ?u.184879
n : Type ?u.184882
inst✝³ : CommRing R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H : IsAlt B
x y : M₁
H1 : ↑(↑B x) y + ↑(↑B y) x = 0
⊢ -↑(↑B x) y = ↑(↑B y) x

tactic: exact H1
state_before: R : Type u_1
R₁ : Type u_3
R₂ : Type ?u.184837
R₃ : Type ?u.184840
M : Type ?u.184843
M₁ : Type u_2
M₂ : Type ?u.184849
Mₗ₁ : Type ?u.184852
Mₗ₁' : Type ?u.184855
Mₗ₂ : Type ?u.184858
Mₗ₂' : Type ?u.184861
K : Type ?u.184864
K₁ : Type ?u.184867
K₂ : Type ?u.184870
V : Type ?u.184873
V₁ : Type ?u.184876
V₂ : Type ?u.184879
n : Type ?u.184882
inst✝³ : CommRing R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H : IsAlt B
x y : M₁
H1 : -↑(↑B x) y = ↑(↑B y) x
⊢ -↑(↑B x) y = ↑(↑B y) x
Theorem: RelIso.cast_trans
File: Mathlib/Order/RelIso/Basic.lean

tactic: subst h₁
state_before: α✝ : Type ?u.81083
β✝ : Type ?u.81086
γ✝ : Type ?u.81089
δ : Type ?u.81092
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ✝ → γ✝ → Prop
u : δ → δ → Prop
α β γ : Type u
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
h₁ : α = β
h₁' : β = γ
h₂ : HEq r s
h₂' : HEq s t
x : α
⊢ ↑(RelIso.trans (RelIso.cast h₁ h₂) (RelIso.cast h₁' h₂')) x = ↑(RelIso.cast (_ : α = γ) (_ : HEq r t)) x

tactic: rfl
state_before: α✝ : Type ?u.81083
β : Type ?u.81086
γ✝ : Type ?u.81089
δ : Type ?u.81092
r✝ : α✝ → α✝ → Prop
s✝ : β → β → Prop
t✝ : γ✝ → γ✝ → Prop
u : δ → δ → Prop
α γ : Type u
r : α → α → Prop
t : γ → γ → Prop
x : α
s : α → α → Prop
h₁' : α = γ
h₂ : HEq r s
h₂' : HEq s t
⊢ ↑(RelIso.trans (RelIso.cast (_ : α = α) h₂) (RelIso.cast h₁' h₂')) x = ↑(RelIso.cast (_ : α = γ) (_ : HEq r t)) x
Theorem: MeasureTheory.Measure.exists_subset_measure_lt_top
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← iSup_restrict_spanningSets hs,
  @lt_iSup_iff _ _ _ r fun i : ℕ => μ.restrict (spanningSets μ i) s] at h's
state_before: α : Type u_1
β : Type ?u.731841
γ : Type ?u.731844
δ : Type ?u.731847
ι : Type ?u.731850
R : Type ?u.731853
R' : Type ?u.731856
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hs : MeasurableSet s
h's : r < ↑↑μ s
⊢ ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < ↑↑μ t ∧ ↑↑μ t < ⊤

tactic: rcases h's with ⟨n, hn⟩
state_before: α : Type u_1
β : Type ?u.731841
γ : Type ?u.731844
δ : Type ?u.731847
ι : Type ?u.731850
R : Type ?u.731853
R' : Type ?u.731856
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hs : MeasurableSet s
h's✝ : r < ↑↑μ s
h's : ∃ i, r < ↑↑(restrict μ (spanningSets μ i)) s
⊢ ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < ↑↑μ t ∧ ↑↑μ t < ⊤

tactic: simp only [restrict_apply hs] at hn
state_before: case intro
α : Type u_1
β : Type ?u.731841
γ : Type ?u.731844
δ : Type ?u.731847
ι : Type ?u.731850
R : Type ?u.731853
R' : Type ?u.731856
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hs : MeasurableSet s
h's : r < ↑↑μ s
n : ℕ
hn : r < ↑↑(restrict μ (spanningSets μ n)) s
⊢ ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < ↑↑μ t ∧ ↑↑μ t < ⊤

tactic: refine'
  ⟨s ∩ spanningSets μ n, hs.inter (measurable_spanningSets _ _), inter_subset_left _ _, hn, _⟩
state_before: case intro
α : Type u_1
β : Type ?u.731841
γ : Type ?u.731844
δ : Type ?u.731847
ι : Type ?u.731850
R : Type ?u.731853
R' : Type ?u.731856
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hs : MeasurableSet s
h's : r < ↑↑μ s
n : ℕ
hn : r < ↑↑μ (s ∩ spanningSets μ n)
⊢ ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < ↑↑μ t ∧ ↑↑μ t < ⊤

tactic: exact (measure_mono (inter_subset_right _ _)).trans_lt (measure_spanningSets_lt_top _ _)
state_before: case intro
α : Type u_1
β : Type ?u.731841
γ : Type ?u.731844
δ : Type ?u.731847
ι : Type ?u.731850
R : Type ?u.731853
R' : Type ?u.731856
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hs : MeasurableSet s
h's : r < ↑↑μ s
n : ℕ
hn : r < ↑↑μ (s ∩ spanningSets μ n)
⊢ ↑↑μ (s ∩ spanningSets μ n) < ⊤
Theorem: Units.ext
File: Mathlib/Algebra/Group/Units.lean

tactic: simp only at e
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
v' i₂ : α
vi₂ : v' * i₂ = 1
iv₂ : i₂ * v' = 1
e : ↑{ val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = ↑{ val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }

tactic: subst v'
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
v' i₂ : α
vi₂ : v' * i₂ = 1
iv₂ : i₂ * v' = 1
e : v = v'
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }

tactic: congr
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v, inv := i₂, val_inv := vi₂, inv_val := iv₂ }

tactic: simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁
state_before: case e_inv
α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ i₁ = i₂
Theorem: Nat.fib_add_two
File: Mathlib/Data/Nat/Fib.lean

tactic: simp [fib, Function.iterate_succ_apply']
state_before: n : ℕ
⊢ fib (n + 2) = fib n + fib (n + 1)
Theorem: Matrix.zpow_neg_one
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: convert DivInvMonoid.zpow_neg' 0 A
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
⊢ A ^ (-1) = A⁻¹

tactic: simp only [zpow_one, Int.ofNat_zero, Int.ofNat_succ, zpow_eq_pow, zero_add]
state_before: case h.e'_3.h.e'_3
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
⊢ A = DivInvMonoid.zpow (↑(Nat.succ 0)) A
Theorem: Tuple.graph.card
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: rw [graph, Finset.card_image_of_injective]
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Finset.card (graph f) = n

tactic: exact Finset.card_fin _
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Finset.card Finset.univ = n

tactic: intro _ _
state_before: case H
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Function.Injective fun i => (f i, i)

tactic: dsimp only
state_before: case H
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
a₁✝ a₂✝ : Fin n
⊢ (fun i => (f i, i)) a₁✝ = (fun i => (f i, i)) a₂✝ → a₁✝ = a₂✝

tactic: rw [Prod.ext_iff]
state_before: case H
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
a₁✝ a₂✝ : Fin n
⊢ (f a₁✝, a₁✝) = (f a₂✝, a₂✝) → a₁✝ = a₂✝

tactic: simp
state_before: case H
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
a₁✝ a₂✝ : Fin n
⊢ (f a₁✝, a₁✝).fst = (f a₂✝, a₂✝).fst ∧ (f a₁✝, a₁✝).snd = (f a₂✝, a₂✝).snd → a₁✝ = a₂✝
Theorem: Finset.mem_eraseNone
File: Mathlib/Data/Finset/Option.lean

tactic: simp [eraseNone]
state_before: α : Type u_1
β : Type ?u.7248
s : Finset (Option α)
x : α
⊢ x ∈ ↑eraseNone s ↔ some x ∈ s
Theorem: ENNReal.iInf_ne_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [iInf_subtype', cinfi_ne_top]
state_before: α : Type u_1
β : Type ?u.38037
a b c d : ℝ≥0∞
r p q : ℝ≥0
inst✝ : CompleteLattice α
f : ℝ≥0∞ → α
⊢ (⨅ (x : ℝ≥0∞) (_ : x ≠ ⊤), f x) = ⨅ (x : ℝ≥0), f ↑x
Theorem: Equiv.Perm.coe_support_eq_set_support
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: ext
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ ↑(support f) = {x | ↑f x ≠ x}

tactic: simp
state_before: case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x✝ : α
⊢ x✝ ∈ ↑(support f) ↔ x✝ ∈ {x | ↑f x ≠ x}