1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.Dart.ext_iff
File: Mathlib/Combinatorics/SimpleGraph/Dart.lean

tactic: cases d₁
state_before: V : Type u_1
G : SimpleGraph V
d₁ d₂ : G.Dart
⊢ d₁ = d₂ ↔ d₁.toProd = d₂.toProd
state_after: case mk
V : Type u_1
G : SimpleGraph V
d₂ : G.Dart
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝, adj := adj✝ } = d₂ ↔ { toProd := toProd✝, adj := adj✝ }.toProd = d₂.toProd

tactic: cases d₂
state_before: case mk
V : Type u_1
G : SimpleGraph V
d₂ : G.Dart
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝, adj := adj✝ } = d₂ ↔ { toProd := toProd✝, adj := adj✝ }.toProd = d₂.toProd
state_after: case mk.mk
V : Type u_1
G : SimpleGraph V
toProd✝¹ : V × V
adj✝¹ : G.Adj toProd✝¹.1 toProd✝¹.2
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝¹, adj := adj✝¹ } = { toProd := toProd✝, adj := adj✝ } ↔
    { toProd := toProd✝¹, adj := adj✝¹ }.toProd = { toProd := toProd✝, adj := adj✝ }.toProd

tactic: simp
state_before: case mk.mk
V : Type u_1
G : SimpleGraph V
toProd✝¹ : V × V
adj✝¹ : G.Adj toProd✝¹.1 toProd✝¹.2
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝¹, adj := adj✝¹ } = { toProd := toProd✝, adj := adj✝ } ↔
    { toProd := toProd✝¹, adj := adj✝¹ }.toProd = { toProd := toProd✝, adj := adj✝ }.toProd
state_after: no goals
Theorem: Fin.max_val
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n m : ℕ
a : Fin n
⊢ max (↑a) n = n
state_after: no goals
Theorem: List.mapIdx_append
File: Mathlib/Data/List/Indexes.lean

tactic: induction' K with a J IH generalizing f
state_before: α : Type u
β : Type v
K L : List α
f : ℕ → α → β
⊢ mapIdx f (K ++ L) = mapIdx f K ++ mapIdx (fun i a => f (i + K.length) a) L
state_after: case nil
α : Type u
β : Type v
L : List α
f : ℕ → α → β
⊢ mapIdx f ([] ++ L) = mapIdx f [] ++ mapIdx (fun i a => f (i + [].length) a) L

case cons
α : Type u
β : Type v
L : List α
a : α
J : List α
IH : ∀ (f : ℕ → α → β), mapIdx f (J ++ L) = mapIdx f J ++ mapIdx (fun i a => f (i + J.length) a) L
f : ℕ → α → β
⊢ mapIdx f (a :: J ++ L) = mapIdx f (a :: J) ++ mapIdx (fun i a_1 => f (i + (a :: J).length) a_1) L

tactic: rfl
state_before: case nil
α : Type u
β : Type v
L : List α
f : ℕ → α → β
⊢ mapIdx f ([] ++ L) = mapIdx f [] ++ mapIdx (fun i a => f (i + [].length) a) L
state_after: no goals

tactic: simp [IH fun i ↦ f (i + 1), Nat.add_assoc]
state_before: case cons
α : Type u
β : Type v
L : List α
a : α
J : List α
IH : ∀ (f : ℕ → α → β), mapIdx f (J ++ L) = mapIdx f J ++ mapIdx (fun i a => f (i + J.length) a) L
f : ℕ → α → β
⊢ mapIdx f (a :: J ++ L) = mapIdx f (a :: J) ++ mapIdx (fun i a_1 => f (i + (a :: J).length) a_1) L
state_after: no goals
Theorem: Finset.insert_union_distrib
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [insert_union, union_insert, insert_idem]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ insert a (s ∪ t) = insert a s ∪ insert a t
state_after: no goals
Theorem: inf_sup_assoc_of_le
File: Mathlib/Order/ModularLattice.lean

tactic: rw [inf_comm, sup_comm, ← sup_inf_assoc_of_le y h, inf_comm, sup_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
h : z ≤ x
⊢ x ⊓ y ⊔ z = x ⊓ (y ⊔ z)
state_after: no goals
Theorem: MeasureTheory.toOuterMeasure_trim_eq_trim_toOuterMeasure
File: Mathlib/MeasureTheory/Measure/Trim.lean

tactic: rw [Measure.trim, toMeasure_toOuterMeasure (ms := m)]
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ✝ : Measure α
s : Set α
μ : Measure α
hm : m ≤ m0
⊢ (μ.trim hm).toOuterMeasure = μ.trim
state_after: no goals
Theorem: SimpleGraph.isNClique_one
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp only [isNClique_iff, card_eq_one, and_iff_right_iff_imp]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ G.IsNClique 1 s ↔ ∃ a, s = {a}
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ (∃ a, s = {a}) → G.IsClique ↑s

tactic: rintro ⟨a, rfl⟩
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ (∃ a, s = {a}) → G.IsClique ↑s
state_after: case intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a✝ b c a : α
⊢ G.IsClique ↑{a}

tactic: simp
state_before: case intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a✝ b c a : α
⊢ G.IsClique ↑{a}
state_after: no goals
Theorem: NormedSpace.exp_zero
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: simp_rw [exp_eq_tsum, ← expSeries_apply_eq, expSeries_apply_zero, tsum_pi_single]
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
⊢ exp 𝕂 0 = 1
state_after: no goals
Theorem: dist_pointReflection_left
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: simp [dist_eq_norm_vsub V, Equiv.pointReflection_vsub_left (G := V)]
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p q : P
⊢ dist ((Equiv.pointReflection p) q) p = dist p q
state_after: no goals
Theorem: Ideal.powQuotSuccInclusion_injective
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rw [← LinearMap.ker_eq_bot, LinearMap.ker_eq_bot']
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
⊢ Function.Injective ⇑(powQuotSuccInclusion f p P i)
state_after: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
⊢ ∀ (m : ↥(map (Quotient.mk (P ^ e)) (P ^ (i + 1)))), (powQuotSuccInclusion f p P i) m = 0 → m = 0

tactic: rintro ⟨x, hx⟩ hx0
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
⊢ ∀ (m : ↥(map (Quotient.mk (P ^ e)) (P ^ (i + 1)))), (powQuotSuccInclusion f p P i) m = 0 → m = 0
state_after: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : (powQuotSuccInclusion f p P i) ⟨x, hx⟩ = 0
⊢ ⟨x, hx⟩ = 0

tactic: rw [Subtype.ext_iff] at hx0 ⊢
state_before: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : (powQuotSuccInclusion f p P i) ⟨x, hx⟩ = 0
⊢ ⟨x, hx⟩ = 0
state_after: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : ↑((powQuotSuccInclusion f p P i) ⟨x, hx⟩) = ↑0
⊢ ↑⟨x, hx⟩ = ↑0

tactic: rwa [powQuotSuccInclusion_apply_coe] at hx0
state_before: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : ↑((powQuotSuccInclusion f p P i) ⟨x, hx⟩) = ↑0
⊢ ↑⟨x, hx⟩ = ↑0
state_after: no goals
Theorem: BoxIntegral.integralSum_add
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simp only [integralSum, Pi.add_apply, (vol _).map_add, Finset.sum_add_distrib]
state_before: ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
⊢ integralSum (f + g) vol π = integralSum f vol π + integralSum g vol π
state_after: no goals
Theorem: Quaternion.sq_eq_normSq
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [← star_eq_self, ← star_mul_self, sq, mul_eq_mul_right_iff, eq_comm]
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ a ^ 2 = ↑(normSq a) ↔ a = ↑a.re
state_after: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ star a = a ∨ a = 0 ↔ star a = a

tactic: exact or_iff_left_of_imp fun ha ↦ ha.symm ▸ star_zero _
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ star a = a ∨ a = 0 ↔ star a = a
state_after: no goals
Theorem: Stream'.WSeq.mem_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: cases' s with f al
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
⊢ a ∈ s.think ↔ a ∈ s
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ a ∈ think ⟨f, al⟩ ↔ a ∈ ⟨f, al⟩

tactic: change (some (some a) ∈ some none::f) ↔ some (some a) ∈ f
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ a ∈ think ⟨f, al⟩ ↔ a ∈ ⟨f, al⟩
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ some (some a) ∈ some none :: f ↔ some (some a) ∈ f

tactic: constructor <;> intro h
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ some (some a) ∈ some none :: f ↔ some (some a) ∈ f
state_after: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
⊢ some (some a) ∈ f

case mk.mpr
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ f
⊢ some (some a) ∈ some none :: f

tactic: apply (Stream'.eq_or_mem_of_mem_cons h).resolve_left
state_before: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
⊢ some (some a) ∈ f
state_after: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
⊢ ¬some (some a) = some none

tactic: intro
state_before: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
⊢ ¬some (some a) = some none
state_after: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
a✝ : some (some a) = some none
⊢ False

tactic: injections
state_before: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
a✝ : some (some a) = some none
⊢ False
state_after: no goals

tactic: apply Stream'.mem_cons_of_mem _ h
state_before: case mk.mpr
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ f
⊢ some (some a) ∈ some none :: f
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.lift_φ₂
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: simp [φ₂]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
a : A ⟶ S.L₁.X₂
b : A ⟶ S.L₀.X₃
h : a ≫ S.L₁.g = b ≫ S.v₀₁.τ₃
⊢ pullback.lift a b h ≫ S.φ₂ = a ≫ S.v₁₂.τ₂
state_after: no goals
Theorem: CategoryTheory.mem_isoClosure_iff
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

tactic: rfl
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
X : C
⊢ isoClosure P X ↔ ∃ Y x, Nonempty (X ≅ Y)
state_after: no goals
Theorem: Int.natAbs_inj_of_nonpos_of_nonneg
File: Mathlib/Data/Int/Lemmas.lean

tactic: simpa only [Int.natAbs_neg] using natAbs_inj_of_nonneg_of_nonneg (neg_nonneg_of_nonpos ha) hb
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : a ≤ 0
hb : 0 ≤ b
⊢ a.natAbs = b.natAbs ↔ -a = b
state_after: no goals
Theorem: Ideal.snd_comp_quotientMulEquivQuotientProd
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: apply Quotient.ringHom_ext
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ (snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime) = factor (I * J) J ⋯
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ ((snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J)) =
    (factor (I * J) J ⋯).comp (Quotient.mk (I * J))

tactic: ext
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
⊢ ((snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J)) =
    (factor (I * J) J ⋯).comp (Quotient.mk (I * J))
state_after: case h.a
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
x✝ : R
⊢ (((snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J))) x✝ =
    ((factor (I * J) J ⋯).comp (Quotient.mk (I * J))) x✝

tactic: rfl
state_before: case h.a
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
ι : Type u_1
I J : Ideal R
coprime : IsCoprime I J
x✝ : R
⊢ (((snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime)).comp (Quotient.mk (I * J))) x✝ =
    ((factor (I * J) J ⋯).comp (Quotient.mk (I * J))) x✝
state_after: no goals
Theorem: CategoryTheory.Functor.map_commSq
File: Mathlib/CategoryTheory/CommSq.lean

tactic: simpa using congr_arg (fun k : W ⟶ Z => F.map k) s.w
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
D : Type u_2
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
s : CommSq f g h i
⊢ F.map f ≫ F.map h = F.map g ≫ F.map i
state_after: no goals
Theorem: Real.Angle.tan_coe
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
state_before: x : ℝ
⊢ (↑x).tan = Real.tan x
state_after: no goals
Theorem: thickening_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [← thickening_singleton, thickening_thickening hε hδ, thickening_singleton]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 < δ
x : E
⊢ thickening ε (Metric.ball x δ) = Metric.ball x (ε + δ)
state_after: no goals
Theorem: Traversable.map_traverse
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: rw [map_eq_traverse_id f]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ map f <$> traverse g x = traverse (map f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (pure ∘ f) <$> traverse g x = traverse (map f ∘ g) x

tactic: refine (comp_traverse (pure ∘ f) g x).symm.trans ?_
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (pure ∘ f) <$> traverse g x = traverse (map f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (Comp.mk ∘ map (pure ∘ f) ∘ g) x = traverse (map f ∘ g) x

tactic: congr
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (Comp.mk ∘ map (pure ∘ f) ∘ g) x = traverse (map f ∘ g) x
state_after: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ Comp.instApplicativeComp = inst✝³

tactic: apply Comp.applicative_comp_id
state_before: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
state_after: no goals
Theorem: RelIso.symm_apply_rel
File: Mathlib/Order/RelIso/Basic.lean

tactic: rw [← e.map_rel_iff, e.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e : r ≃r s
x : β
y : α
⊢ r (e.symm x) y ↔ s x (e y)
state_after: no goals
Theorem: MeasureTheory.integral_subtype_comap
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [← map_comap_subtype_coe hs]
state_before: α✝ : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α✝ → E
m : MeasurableSpace α✝
μ✝ : Measure α✝
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α✝
α : Type u_7
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → G
⊢ ∫ (x : ↑s), f ↑x ∂Measure.comap Subtype.val μ = ∫ (x : α) in s, f x ∂μ
state_after: α✝ : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α✝ → E
m : MeasurableSpace α✝
μ✝ : Measure α✝
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α✝
α : Type u_7
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → G
⊢ ∫ (x : ↑s), f ↑x ∂Measure.comap Subtype.val μ = ∫ (x : α), f x ∂Measure.map Subtype.val (Measure.comap Subtype.val μ)

tactic: exact ((MeasurableEmbedding.subtype_coe hs).integral_map _).symm
state_before: α✝ : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α✝ → E
m : MeasurableSpace α✝
μ✝ : Measure α✝
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α✝
α : Type u_7
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → G
⊢ ∫ (x : ↑s), f ↑x ∂Measure.comap Subtype.val μ = ∫ (x : α), f x ∂Measure.map Subtype.val (Measure.comap Subtype.val μ)
state_after: no goals
Theorem: ProbabilityTheory.isCondKernelCDF_condCDF
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

tactic: simp_rw [condCDF_eq_stieltjesOfMeasurableRat_unit_prod ρ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ IsCondKernelCDF (fun p => condCDF ρ p.2) (kernel.const Unit ρ) (kernel.const Unit ρ.fst)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ IsCondKernelCDF (fun p => stieltjesOfMeasurableRat (fun p r => (preCDF ρ r p.2).toReal) ⋯ ((), p.2))
    (kernel.const Unit ρ) (kernel.const Unit ρ.fst)

tactic: exact isCondKernelCDF_stieltjesOfMeasurableRat (isRatCondKernelCDF_preCDF ρ)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ IsCondKernelCDF (fun p => stieltjesOfMeasurableRat (fun p r => (preCDF ρ r p.2).toReal) ⋯ ((), p.2))
    (kernel.const Unit ρ) (kernel.const Unit ρ.fst)
state_after: no goals
Theorem: ball_mul_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, singleton_mul_ball, mul_comm y]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ * {y} = ball (x * y) δ
state_after: no goals
Theorem: ProbabilityTheory.gaussianReal_map_mul_const
File: Mathlib/Probability/Distributions/Gaussian.lean

tactic: simp_rw [mul_comm _ c]
state_before: μ : ℝ
v : ℝ≥0
c : ℝ
⊢ Measure.map (fun x => x * c) (gaussianReal μ v) = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: μ : ℝ
v : ℝ≥0
c : ℝ
⊢ Measure.map (fun x => c * x) (gaussianReal μ v) = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)

tactic: exact gaussianReal_map_const_mul c
state_before: μ : ℝ
v : ℝ≥0
c : ℝ
⊢ Measure.map (fun x => c * x) (gaussianReal μ v) = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: no goals
Theorem: catalan_succ
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

tactic: rw [catalan]
state_before: n : ℕ
⊢ catalan (n + 1) = ∑ i : Fin n.succ, catalan ↑i * catalan (n - ↑i)
state_after: no goals
Theorem: ZMod.χ₄_int_eq_if_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: have help : ∀ m : ℤ, 0 ≤ m → m < 4 → χ₄ m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1 := by
  decide
state_before: n : ℤ
⊢ χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
state_after: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1

tactic: rw [← Int.emod_emod_of_dvd n (by omega : (2 : ℤ) ∣ 4), ← ZMod.intCast_mod n 4]
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
state_after: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ χ₄ ↑(n % ↑4) = if n % 4 % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1

tactic: exact help (n % 4) (Int.emod_nonneg n (by omega)) (Int.emod_lt n (by omega))
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ χ₄ ↑(n % ↑4) = if n % 4 % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
state_after: no goals

tactic: decide
state_before: n : ℤ
⊢ ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
state_after: no goals

tactic: omega
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ 2 ∣ 4
state_after: no goals

tactic: omega
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 4 → χ₄ ↑m = if m % 2 = 0 then 0 else if m = 1 then 1 else -1
⊢ 4 ≠ 0
state_after: no goals