1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: mem_uniformity_of_uniformContinuous_invariant
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [UniformContinuous, uniformity_prod_eq_prod, tendsto_map'_iff] at hf
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : UniformContinuous fun p => f p.1 p.2
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s

tactic: rcases mem_prod_iff.1 (mem_map.1 <| hf hs) with ⟨u, hu, v, hv, huvt⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
u : Set (α × α)
hu : u ∈ 𝓤 α
v : Set (α × α)
hv : v ∈ 𝓤 α
huvt : u ×ˢ v ⊆ ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' s
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s

tactic: exact ⟨u, hu, fun a b c hab => @huvt ((_, _), (_, _)) ⟨hab, refl_mem_uniformity hv⟩⟩
state_before: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
u : Set (α × α)
hu : u ∈ 𝓤 α
v : Set (α × α)
hv : v ∈ 𝓤 α
huvt : u ×ˢ v ⊆ ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' s
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: no goals
Theorem: SModEq.bot
File: Mathlib/LinearAlgebra/SModEq.lean

tactic: rw [SModEq.def, Submodule.Quotient.eq, mem_bot, sub_eq_zero]
state_before: R : Type u_1
inst✝⁵ : Ring R
A : Type u_2
inst✝⁴ : CommRing A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type u_4
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
⊢ x ≡ y [SMOD ⊥] ↔ x = y
state_after: no goals
Theorem: add_self_div_two
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← mul_two, mul_div_cancel_right₀ a two_ne_zero]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
⊢ (a + a) / 2 = a
state_after: no goals
Theorem: Orientation.sin_oangle_add_right_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: have hs : (o.oangle x (x + y)).sign = 1 := by
  rw [oangle_sign_add_right, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle x (x + y)).sin = ‖y‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle x (x + y)).sign = 1
⊢ (o.oangle x (x + y)).sin = ‖y‖ / ‖x + y‖

tactic: rw [o.oangle_eq_angle_of_sign_eq_one hs, Real.Angle.sin_coe,
  InnerProductGeometry.sin_angle_add_of_inner_eq_zero (o.inner_eq_zero_of_oangle_eq_pi_div_two h)
    (Or.inl (o.left_ne_zero_of_oangle_eq_pi_div_two h))]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle x (x + y)).sign = 1
⊢ (o.oangle x (x + y)).sin = ‖y‖ / ‖x + y‖
state_after: no goals

tactic: rw [oangle_sign_add_right, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle x (x + y)).sign = 1
state_after: no goals
Theorem: LipschitzWith.const_min
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [min_comm] using hf.min_const a
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => min a (f x)
state_after: no goals
Theorem: Ordinal.mul_isNormal
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: beta_reduce
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : 0 < a
b : Ordinal.{u_4}
⊢ (fun x => a * x) b < (fun x => a * x) (succ b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : 0 < a
b : Ordinal.{u_4}
⊢ a * b < a * succ b

tactic: rw [mul_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : 0 < a
b : Ordinal.{u_4}
⊢ a * b < a * succ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : 0 < a
b : Ordinal.{u_4}
⊢ a * b < a * b + a

tactic: simpa only [add_zero] using (add_lt_add_iff_left (a * b)).2 h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : 0 < a
b : Ordinal.{u_4}
⊢ a * b < a * b + a
state_after: no goals
Theorem: Set.Finite.toFinset_diff
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s \ t).Finite
⊢ h.toFinset = hs.toFinset \ ht.toFinset
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s \ t).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ hs.toFinset \ ht.toFinset

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s \ t).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ hs.toFinset \ ht.toFinset
state_after: no goals
Theorem: Finset.erase_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simpa only [inter_comm t] using inter_erase a t s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ s.erase a ∩ t = (s ∩ t).erase a
state_after: no goals
Theorem: Subalgebra.finrank_sup_eq_finrank_left_mul_finrank_of_free
File: Mathlib/Algebra/Algebra/Subalgebra/Rank.lean

tactic: simpa only [map_mul] using congr(Cardinal.toNat $(rank_sup_eq_rank_left_mul_rank_of_free A B))
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
A B : Subalgebra R S
inst✝³ : Module.Free R ↥A
inst✝² : Module.Free R ↥B
inst✝¹ : Module.Free ↥A ↥(Algebra.adjoin ↥A ↑B)
inst✝ : Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)
⊢ finrank R ↥(A ⊔ B) = finrank R ↥A * finrank ↥A ↥(Algebra.adjoin ↥A ↑B)
state_after: no goals
Theorem: Ultrafilter.le_sup_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [← disjoint_iff_not_le, not_or, disjoint_sup_right]
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
u : Ultrafilter α
f g : Filter α
⊢ ¬↑u ≤ f ⊔ g ↔ ¬(↑u ≤ f ∨ ↑u ≤ g)
state_after: no goals
Theorem: RatFunc.mk_coe_def
File: Mathlib/FieldTheory/RatFunc/Defs.lean

tactic: simp only [mk_eq_div', ← Localization.mk_eq_mk', FractionRing.mk_eq_div]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p : K[X]
q : ↥K[X]⁰
⊢ RatFunc.mk p ↑q = { toFractionRing := IsLocalization.mk' (FractionRing K[X]) p q }
state_after: no goals
Theorem: ModularGroup.T_inv_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simpa using T_pow_mul_apply_one (-1) g
state_before: g : SL(2, ℤ)
⊢ ↑(T⁻¹ * g) 1 = ↑g 1
state_after: no goals
Theorem: Filter.HasBasis.cauchySeq_iff
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rw [cauchySeq_iff_tendsto, ← prod_atTop_atTop_eq]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ Tendsto (Prod.map u u) (atTop ×ˢ atTop) (𝓤 α) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i

tactic: refine (atTop_basis.prod_self.tendsto_iff h).trans ?_
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ Tendsto (Prod.map u u) (atTop ×ˢ atTop) (𝓤 α) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ (∀ (ib : γ), p ib → ∃ ia, True ∧ ∀ x ∈ Ici ia ×ˢ Ici ia, Prod.map u u x ∈ s ib) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i

tactic: simp only [exists_prop, true_and_iff, MapsTo, preimage, subset_def, Prod.forall, mem_prod_eq,
  mem_setOf_eq, mem_Ici, and_imp, Prod.map, ge_iff_le, @forall_swap (_ ≤ _) β]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ (∀ (ib : γ), p ib → ∃ ia, True ∧ ∀ x ∈ Ici ia ×ˢ Ici ia, Prod.map u u x ∈ s ib) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: no goals
Theorem: Polynomial.image_rootSet
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: classical
  rw [rootSet, ← Finset.coe_image, ← Multiset.toFinset_map, ← f.coe_toRingHom,
    ← roots_map _ ((splits_id_iff_splits (algebraMap R K)).mpr h), map_map, f.comp_algebraMap,
    ← rootSet]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ ⇑f '' p.rootSet K = p.rootSet L
state_after: no goals

tactic: rw [rootSet, ← Finset.coe_image, ← Multiset.toFinset_map, ← f.coe_toRingHom,
  ← roots_map _ ((splits_id_iff_splits (algebraMap R K)).mpr h), map_map, f.comp_algebraMap,
  ← rootSet]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ ⇑f '' p.rootSet K = p.rootSet L
state_after: no goals
Theorem: Finpartition.exists_enumeration
File: Mathlib/Order/Partition/Finpartition.lean

tactic: use P.equivSigmaParts.trans ((Equiv.refl _).sigmaCongr (fun t ↦ t.1.equivFin))
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∃ f, ∀ (a b : { x // x ∈ s }), P.part ↑a = P.part ↑b ↔ (f a).fst = (f b).fst
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∀ (a b : { x // x ∈ s }),
    P.part ↑a = P.part ↑b ↔
      ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) a).fst =
        ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) b).fst

tactic: simp [equivSigmaParts, Equiv.sigmaCongr, Equiv.sigmaCongrLeft]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∀ (a b : { x // x ∈ s }),
    P.part ↑a = P.part ↑b ↔
      ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) a).fst =
        ((P.equivSigmaParts.trans ((Equiv.refl { x // x ∈ P.parts }).sigmaCongr fun t => (↑t).equivFin)) b).fst
state_after: no goals
Theorem: iterateFrobeniusEquiv_eq_pow
File: Mathlib/FieldTheory/Perfect.lean

tactic: rw [map_pow, Equiv.Perm.coe_pow]
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = ⇑((RingAut.toPerm R) (frobeniusEquiv R p ^ n))
state_after: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = (⇑((RingAut.toPerm R) (frobeniusEquiv R p)))^[n]

tactic: exact (pow_iterate p n).symm
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = (⇑((RingAut.toPerm R) (frobeniusEquiv R p)))^[n]
state_after: no goals
Theorem: Set.unbounded_lt_inter_not_lt
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Unbounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Unbounded (fun x x_1 => x < x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Bounded (fun x x_1 => x < x_1) s

tactic: exact bounded_lt_inter_not_lt a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Bounded (fun x x_1 => x < x_1) s
state_after: no goals
Theorem: Stream'.tail_even
File: Mathlib/Data/Stream/Init.lean

tactic: unfold even
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ s.even.tail = s.tail.tail.even
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (corec (fun s => s.head) (fun s => s.tail.tail) s).tail = corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail

tactic: rw [corec_eq]
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (corec (fun s => s.head) (fun s => s.tail.tail) s).tail = corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (s.head :: corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail).tail =
    corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (s.head :: corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail).tail =
    corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
state_after: no goals
Theorem: PMF.bindOnSupport_eq_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp only [bindOnSupport_apply, ENNReal.tsum_eq_zero, mul_eq_zero, or_iff_not_imp_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (p.bindOnSupport f) b = 0 ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∀ (i : α), ¬p i = 0 → (if h : p i = 0 then 0 else (f i h) b) = 0) ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0

tactic: exact ⟨fun h a ha => Trans.trans (dif_neg ha).symm (h a ha),
  fun h a ha => Trans.trans (dif_neg ha) (h a ha)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∀ (i : α), ¬p i = 0 → (if h : p i = 0 then 0 else (f i h) b) = 0) ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0
state_after: no goals
Theorem: WeierstrassCurve.VariableChange.id_comp
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [comp, id, zero_add, zero_mul, mul_zero, one_mul]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C✝ C' C'' C : VariableChange R
⊢ id.comp C = C
state_after: no goals
Theorem: MvPolynomial.comap_rename
File: Mathlib/Algebra/MvPolynomial/Comap.lean

tactic: funext
state_before: σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
f : σ → τ
x : τ → R
⊢ comap (rename f) x = x ∘ f
state_after: case h
σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
f : σ → τ
x : τ → R
x✝ : σ
⊢ comap (rename f) x x✝ = (x ∘ f) x✝

tactic: simp [rename_X, comap_apply, aeval_X]
state_before: case h
σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
f : σ → τ
x : τ → R
x✝ : σ
⊢ comap (rename f) x x✝ = (x ∘ f) x✝
state_after: no goals
Theorem: LinearMap.graph_eq_range_prod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ f.graph = range (id.prod f)
state_after: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M × M₂
⊢ x ∈ f.graph ↔ x ∈ range (id.prod f)

tactic: exact ⟨fun hx => ⟨x.1, Prod.ext rfl hx.symm⟩, fun ⟨u, hu⟩ => hu ▸ rfl⟩
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M × M₂
⊢ x ∈ f.graph ↔ x ∈ range (id.prod f)
state_after: no goals
Theorem: OrthonormalBasis.det_eq_neg_det_of_opposite_orientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: rw [e.toBasis.det.eq_smul_basis_det f.toBasis]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : e.toBasis.orientation ≠ f.toBasis.orientation
⊢ e.toBasis.det = -f.toBasis.det
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : e.toBasis.orientation ≠ f.toBasis.orientation
⊢ e.toBasis.det ⇑f.toBasis • f.toBasis.det = -f.toBasis.det

tactic: simp [e.det_to_matrix_orthonormalBasis_of_opposite_orientation f h,
  neg_one_smul ℝ (M := E [⋀^ι]→ₗ[ℝ] ℝ)]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : e.toBasis.orientation ≠ f.toBasis.orientation
⊢ e.toBasis.det ⇑f.toBasis • f.toBasis.det = -f.toBasis.det
state_after: no goals
Theorem: DFinsupp.single_apply
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [single_eq_pi_single, Pi.single, Function.update]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (single i b) i' = if h : i = i' then Eq.recOn h b else 0
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (if h : i' = i then ⋯ ▸ b else 0 i') = if h : i = i' then Eq.recOn h b else 0

tactic: simp [@eq_comm _ i i']
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
⊢ (if h : i' = i then ⋯ ▸ b else 0 i') = if h : i = i' then Eq.recOn h b else 0
state_after: no goals
Theorem: PMF.coe_le_one
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: refine hasSum_le (fun b => ?_) (hasSum_ite_eq a (p a)) (hasSum_coe_one p)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
a : α
⊢ p a ≤ 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
a b : α
⊢ (if b = a then p a else 0) ≤ p b

tactic: split_ifs with h <;> simp only [h, zero_le', le_rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
a b : α
⊢ (if b = a then p a else 0) ≤ p b
state_after: no goals
Theorem: Nat.ord_proj_pos
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: if pp : p.Prime then simp [pow_pos pp.pos] else simp [pp]
state_before: a b m n✝ p✝ n p : ℕ
⊢ 0 < p ^ n.factorization p
state_after: no goals

tactic: simp [pow_pos pp.pos]
state_before: a b m n✝ p✝ n p : ℕ
pp : Prime p
⊢ 0 < p ^ n.factorization p
state_after: no goals

tactic: simp [pp]
state_before: a b m n✝ p✝ n p : ℕ
pp : ¬Prime p
⊢ 0 < p ^ n.factorization p
state_after: no goals
Theorem: AffineSubspace.comap_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← ext_iff]
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type u_6
P₃ : Type u_7
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₃
f : P₁ →ᵃ[k] P₂
⊢ comap f ⊤ = ⊤
state_after: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type u_6
P₃ : Type u_7
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₃
f : P₁ →ᵃ[k] P₂
⊢ ↑(comap f ⊤) = ↑⊤

tactic: exact preimage_univ (f := f)
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type u_6
P₃ : Type u_7
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₃
f : P₁ →ᵃ[k] P₂
⊢ ↑(comap f ⊤) = ↑⊤
state_after: no goals