tasksource/leandojo huggingface dataset:
Theorem: div_lt_div_iff'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simpa only [div_eq_mul_inv] using mul_inv_lt_mul_inv_iff'
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a / b < c / d ↔ a * d < c * b
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.140996
u v : UniformSpace α
⊢ u ≤ v ↔ UniformContinuous id
Theorem: ENNReal.ofReal_lt_ofReal_iff_of_nonneg
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.ofReal, ENNReal.ofReal, coe_lt_coe, Real.toNNReal_lt_toNNReal_iff_of_nonneg hp]
state_before: α : Type ?u.807039
β : Type ?u.807042
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hp : 0 ≤ p
⊢ ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q
Theorem: Substring.ValidFor.valid
File: Std/Data/String/Lemmas.lean

tactic: simp
state_before: l m r : List Char
⊢ l ++ (m ++ r) =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.startPos.byteIdx =
      utf8Len l

tactic: simp
state_before: l m r : List Char
⊢ l ++ m ++ r =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.stopPos.byteIdx =
      utf8Len (l ++ m)
Theorem: FirstOrder.Language.Substructure.reduct_withConstants
File: Mathlib/ModelTheory/Substructures.lean

tactic: ext
state_before: L : Language
M : Type w
N : Type ?u.671067
P : Type ?u.671070
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
A s : Set M
h : A ⊆ ↑S
⊢ ↑(LHom.substructureReduct (lhomWithConstants L ↑A)) (withConstants S h) = S

tactic: simp
state_before: case h
L : Language
M : Type w
N : Type ?u.671067
P : Type ?u.671070
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
A s : Set M
h : A ⊆ ↑S
x✝ : M
⊢ x✝ ∈ ↑(LHom.substructureReduct (lhomWithConstants L ↑A)) (withConstants S h) ↔ x✝ ∈ S
Theorem: RingQuot.mkAlgHom_rel
File: Mathlib/Algebra/RingQuot.lean

tactic: simp [mkAlgHom_def, mkRingHom_def, Quot.sound (Rel.of w)]
state_before: R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝ : Semiring T
s : A → A → Prop
x y : A
w : s x y
⊢ ↑(mkAlgHom S s) x = ↑(mkAlgHom S s) y
Theorem: List.inter_cons_of_not_mem
File: Mathlib/Data/List/Lattice.lean

tactic: simp only [instInterList, List.inter, filter_cons_of_neg, h]
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ l₂
⊢ (a :: l₁) ∩ l₂ = l₁ ∩ l₂
Theorem: MvPolynomial.range_evalᵢ
File: Mathlib/FieldTheory/Finite/Polynomial.lean

tactic: rw [evalᵢ, LinearMap.range_comp, range_subtype]
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Finite σ
⊢ range (evalᵢ σ K) = ⊤

tactic: exact map_restrict_dom_evalₗ K σ
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Finite σ
⊢ Submodule.map (evalₗ K σ) (restrictDegree σ K (Fintype.card K - 1)) = ⊤
Theorem: zpow_one_add
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [zpow_add, zpow_one]
state_before: α : Type ?u.138627
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
i : ℤ
⊢ a ^ (1 + i) = a * a ^ i
Theorem: Matrix.vecMul_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.908244
m : Type u_1
n : Type u_2
o : Type ?u.908253
m' : o → Type ?u.908258
n' : o → Type ?u.908263
R : Type ?u.908266
S : Type ?u.908269
α : Type v
β : Type w
γ : Type ?u.908276
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
⊢ vecMul v (-A) = -vecMul v A

tactic: apply dotProduct_neg
state_before: case h
l : Type ?u.908244
m : Type u_1
n : Type u_2
o : Type ?u.908253
m' : o → Type ?u.908258
n' : o → Type ?u.908263
R : Type ?u.908266
S : Type ?u.908269
α : Type v
β : Type w
γ : Type ?u.908276
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
x✝ : n
⊢ vecMul v (-A) x✝ = (-vecMul v A) x✝
Theorem: OrderMonoidWithZeroHom.cancel_right
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: congr
state_before: F : Type ?u.136049
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.136061
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f✝ g : α →*₀o β
g₁ g₂ : β →*₀o γ
f : α →*₀o β
hf : Surjective ↑f
x✝ : g₁ = g₂
⊢ comp g₁ f = comp g₂ f
Theorem: CategoryTheory.isIso_of_epi_of_isSplitMono
File: Mathlib/CategoryTheory/EpiMono.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X Y : C
f : X ⟶ Y
inst✝¹ : IsSplitMono f
inst✝ : Epi f
⊢ f ≫ retraction f = 𝟙 X

tactic: simp [← cancel_epi f]
state_before: C : Type u₁
inst✝² : Category C
X Y : C
f : X ⟶ Y
inst✝¹ : IsSplitMono f
inst✝ : Epi f
⊢ retraction f ≫ f = 𝟙 Y
Theorem: fderivWithin_eq_fderiv
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← fderivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.352325
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.352420
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hs : UniqueDiffWithinAt 𝕜 s x
h : DifferentiableAt 𝕜 f x
⊢ fderivWithin 𝕜 f s x = fderiv 𝕜 f x

tactic: exact fderivWithin_subset (subset_univ _) hs h.differentiableWithinAt
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.352325
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.352420
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hs : UniqueDiffWithinAt 𝕜 s x
h : DifferentiableAt 𝕜 f x
⊢ fderivWithin 𝕜 f s x = fderivWithin 𝕜 f univ x
Theorem: TopCat.pullbackIsoProdSubtype_inv_snd
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: simp [pullbackCone, pullbackIsoProdSubtype]
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackIsoProdSubtype f g).inv ≫ pullback.snd = pullbackSnd f g
Theorem: gaugeSeminorm_ball_one
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rw [Seminorm.ball_zero_eq]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.250152
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module ℝ E
s t : Set E
a : ℝ
inst✝⁴ : IsROrC 𝕜
inst✝³ : Module 𝕜 E
inst✝² : IsScalarTower ℝ 𝕜 E
hs₀ : Balanced 𝕜 s
hs₁ : Convex ℝ s
hs₂ : Absorbent ℝ s
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : IsOpen s
⊢ Seminorm.ball (gaugeSeminorm hs₀ hs₁ hs₂) 0 1 = s

tactic: exact gauge_lt_one_eq_self_of_open hs₁ hs₂.zero_mem hs
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.250152
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module ℝ E
s t : Set E
a : ℝ
inst✝⁴ : IsROrC 𝕜
inst✝³ : Module 𝕜 E
inst✝² : IsScalarTower ℝ 𝕜 E
hs₀ : Balanced 𝕜 s
hs₁ : Convex ℝ s
hs₂ : Absorbent ℝ s
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : IsOpen s
⊢ {y | ↑(gaugeSeminorm hs₀ hs₁ hs₂) y < 1} = s
Theorem: Rat.mul_den_dvd
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [mul_def, normalize_eq]
state_before: q₁ q₂ : ℚ
⊢ (q₁ * q₂).den ∣ q₁.den * q₂.den

tactic: apply Nat.div_dvd_of_dvd
state_before: q₁ q₂ : ℚ
⊢ (mk' (q₁.num * q₂.num / ↑(Nat.gcd (Int.natAbs (q₁.num * q₂.num)) (q₁.den * q₂.den)))
        (q₁.den * q₂.den / Nat.gcd (Int.natAbs (q₁.num * q₂.num)) (q₁.den * q₂.den))).den ∣
    q₁.den * q₂.den

tactic: apply Nat.gcd_dvd_right
state_before: case h
q₁ q₂ : ℚ
⊢ Nat.gcd (Int.natAbs (q₁.num * q₂.num)) (q₁.den * q₂.den) ∣ q₁.den * q₂.den
Theorem: FiniteDimensional.of_fintype_basis
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: cases nonempty_fintype ι
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
⊢ FiniteDimensional K V

tactic: exact ⟨⟨Finset.univ.image h, by
  convert h.span_eq
  simp⟩⟩
state_before: case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ FiniteDimensional K V

tactic: convert h.span_eq
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ span K ↑(Finset.image (↑h) Finset.univ) = ⊤

tactic: simp
state_before: case h.e'_2.h.e'_6
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ ↑(Finset.image (↑h) Finset.univ) = Set.range ↑h
Theorem: IntermediateField.adjoin_le_subfield
File: Mathlib/FieldTheory/Adjoin.lean

tactic: apply Subfield.closure_le.mpr
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : Subfield E
HF : Set.range ↑(algebraMap F E) ⊆ ↑K
HS : S ⊆ ↑K
⊢ toSubfield (adjoin F S) ≤ K

tactic: rw [Set.union_subset_iff]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : Subfield E
HF : Set.range ↑(algebraMap F E) ⊆ ↑K
HS : S ⊆ ↑K
⊢ Set.range ↑(algebraMap F E) ∪ S ⊆ ↑K

tactic: exact ⟨HF, HS⟩
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : Subfield E
HF : Set.range ↑(algebraMap F E) ⊆ ↑K
HS : S ⊆ ↑K
⊢ Set.range ↑(algebraMap F E) ⊆ ↑K ∧ S ⊆ ↑K
Theorem: Nat.left_distrib
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction n generalizing m k with
| zero      => repeat rw [Nat.zero_mul]
| succ n ih => simp [succ_mul, ih]; rw [Nat.add_assoc, Nat.add_assoc (n*m)]; apply congrArg; apply Nat.add_left_comm
state_before: n m k : Nat
⊢ n * (m + k) = n * m + n * k

tactic: repeat rw [Nat.zero_mul]
state_before: case zero
m k : Nat
⊢ zero * (m + k) = zero * m + zero * k

tactic: simp [succ_mul, ih]
state_before: case succ
n : Nat
ih : ∀ (m k : Nat), n * (m + k) = n * m + n * k
m k : Nat
⊢ succ n * (m + k) = succ n * m + succ n * k

tactic: rw [Nat.add_assoc, Nat.add_assoc (n*m)]
state_before: case succ
n : Nat
ih : ∀ (m k : Nat), n * (m + k) = n * m + n * k
m k : Nat
⊢ n * m + n * k + (m + k) = n * m + m + (n * k + k)

tactic: apply congrArg
state_before: case succ
n : Nat
ih : ∀ (m k : Nat), n * (m + k) = n * m + n * k
m k : Nat
⊢ n * m + (n * k + (m + k)) = n * m + (m + (n * k + k))

tactic: apply Nat.add_left_comm
state_before: case succ.h
n : Nat
ih : ∀ (m k : Nat), n * (m + k) = n * m + n * k
m k : Nat
⊢ n * k + (m + k) = m + (n * k + k)
Theorem: Polynomial.cardinal_mk_eq_max
File: Mathlib/Data/Polynomial/Cardinal.lean

tactic: rw [AddMonoidAlgebra, mk_finsupp_lift_of_infinite, lift_uzero, max_comm]
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ (#AddMonoidAlgebra R ℕ) = max (#R) ℵ₀

tactic: rfl
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ max (#R) (lift (#ℕ)) = max (#R) ℵ₀
Theorem: LipschitzWith.norm_compLp_sub_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: apply Lp.norm_le_mul_norm_of_ae_le_mul
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2355804
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f f' : { x // x ∈ Lp E p }
⊢ ‖compLp hg g0 f - compLp hg g0 f'‖ ≤ ↑c * ‖f - f'‖

tactic: filter_upwards [hg.coeFn_compLp g0 f, hg.coeFn_compLp g0 f',
  Lp.coeFn_sub (hg.compLp g0 f) (hg.compLp g0 f'), Lp.coeFn_sub f f'] with a ha1 ha2 ha3 ha4
state_before: case h
α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2355804
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f f' : { x // x ∈ Lp E p }
⊢ ∀ᵐ (x : α) ∂μ, ‖↑↑(compLp hg g0 f - compLp hg g0 f') x‖ ≤ ↑c * ‖↑↑(f - f') x‖

tactic: simp only [ha1, ha2, ha3, ha4, ← dist_eq_norm, Pi.sub_apply, Function.comp_apply]
state_before: case h
α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2355804
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f f' : { x // x ∈ Lp E p }
a : α
ha1 : ↑↑(compLp hg g0 f) a = (g ∘ ↑↑f) a
ha2 : ↑↑(compLp hg g0 f') a = (g ∘ ↑↑f') a
ha3 : ↑↑(compLp hg g0 f - compLp hg g0 f') a = (↑↑(compLp hg g0 f) - ↑↑(compLp hg g0 f')) a
ha4 : ↑↑(f - f') a = (↑↑f - ↑↑f') a
⊢ ‖↑↑(compLp hg g0 f - compLp hg g0 f') a‖ ≤ ↑c * ‖↑↑(f - f') a‖

tactic: exact hg.dist_le_mul (f a) (f' a)
state_before: case h
α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2355804
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f f' : { x // x ∈ Lp E p }
a : α
ha1 : ↑↑(compLp hg g0 f) a = (g ∘ ↑↑f) a
ha2 : ↑↑(compLp hg g0 f') a = (g ∘ ↑↑f') a
ha3 : ↑↑(compLp hg g0 f - compLp hg g0 f') a = (↑↑(compLp hg g0 f) - ↑↑(compLp hg g0 f')) a
ha4 : ↑↑(f - f') a = (↑↑f - ↑↑f') a
⊢ dist (g (↑↑f a)) (g (↑↑f' a)) ≤ ↑c * dist (↑↑f a) (↑↑f' a)
Theorem: FirstOrder.Language.Ultraproduct.sentence_realize
File: Mathlib/ModelTheory/Ultraproducts.lean

tactic: simp_rw [Sentence.Realize]
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → Structure L (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
φ : Sentence L
⊢ Product (↑u) M ⊨ φ ↔ ∀ᶠ (a : α) in ↑u, M a ⊨ φ

tactic: erw [← realize_formula_cast φ, iff_eq_eq]
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → Structure L (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
φ : Sentence L
⊢ Formula.Realize φ default ↔ ∀ᶠ (a : α) in ↑u, Formula.Realize φ default

tactic: exact congr rfl (Subsingleton.elim _ _)
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → Structure L (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
φ : Sentence L
⊢ Formula.Realize φ default = Formula.Realize φ fun i => Quotient.mk' fun a => default i
Theorem: finprod_mem_finset_product
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: classical
  rw [finprod_mem_finset_product']
  simp
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.426329
G : Type ?u.426332
M : Type u_3
N : Type ?u.426338
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
s : Finset (α × β)
f : α × β → M
⊢ (∏ᶠ (ab : α × β) (_ : ab ∈ s), f ab) = ∏ᶠ (a : α) (b : β) (_ : (a, b) ∈ s), f (a, b)

tactic: rw [finprod_mem_finset_product']
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.426329
G : Type ?u.426332
M : Type u_3
N : Type ?u.426338
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
s : Finset (α × β)
f : α × β → M
⊢ (∏ᶠ (ab : α × β) (_ : ab ∈ s), f ab) = ∏ᶠ (a : α) (b : β) (_ : (a, b) ∈ s), f (a, b)

tactic: simp
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.426329
G : Type ?u.426332
M : Type u_3
N : Type ?u.426338
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
s : Finset (α × β)
f : α × β → M
⊢ (∏ᶠ (a : α) (b : β) (_ : b ∈ Finset.image Prod.snd (Finset.filter (fun ab => ab.fst = a) s)), f (a, b)) =
    ∏ᶠ (a : α) (b : β) (_ : (a, b) ∈ s), f (a, b)
Theorem: CategoryTheory.IsPullback.zero_right
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ CommSq 0 (𝟙 X) 0 0

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ ((zeroProdIso X).symm ≪≫ (pullbackZeroZeroIso 0 X).symm).hom ≫ pullback.fst = 0

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ ((zeroProdIso X).symm ≪≫ (pullbackZeroZeroIso 0 X).symm).hom ≫ pullback.snd = 𝟙 X
Theorem: Finset.map_subset_map
File: Mathlib/Data/Finset/Image.lean

tactic: simp [subset_def, Multiset.map_subset_map h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.27657
f : α ↪ β
s s₁ s₂ : Finset α
h : s₁ ⊆ s₂
⊢ map f s₁ ⊆ map f s₂
Theorem: Int.floor_eq_zero_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [floor_eq_iff]
state_before: F : Type ?u.140446
α : Type u_1
β : Type ?u.140452
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ = 0 ↔ a ∈ Ico 0 1
Theorem: List.nodup_sublistsLen
File: Mathlib/Data/List/Sublists.lean

tactic: have : Pairwise (. ≠ .) l.sublists' := Pairwise.imp
  (fun h => Lex.to_ne (by convert h using 3; simp [swap, eq_comm])) h.sublists'
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h : Nodup l
⊢ Nodup (sublistsLen n l)

tactic: exact this.sublist (sublistsLen_sublist_sublists' _ _)
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h : Nodup l
this : Pairwise (fun x x_1 => x ≠ x_1) (sublists' l)
⊢ Nodup (sublistsLen n l)

tactic: convert h using 3
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h✝ : Nodup l
a✝ b✝ : List α
h : Lex (swap fun x x_1 => x ≠ x_1) a✝ b✝
⊢ Lex (fun x x_1 => x ≠ x_1) a✝ b✝

tactic: simp [swap, eq_comm]
state_before: case h.e'_2.h.e'_4.h.h
α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h✝ : Nodup l
a✝ b✝ : List α
h : Lex (swap fun x x_1 => x ≠ x_1) a✝ b✝
x✝ : α
⊢ (fun x => ¬x = x✝) = fun x => x✝ ≠ x
Theorem: List.perm_append_singleton
File: Mathlib/Data/List/Perm.lean

tactic: rw [append_nil]
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
a : α
l : List α
⊢ a :: (l ++ []) ~ a :: l
Theorem: bit0_lt_bit0
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [bit0, bit0, ← two_mul, ← two_mul, mul_lt_mul_left (zero_lt_two : 0 < (2 : α))]
state_before: α : Type u
β : Type ?u.124569
inst✝ : LinearOrderedSemiring α
a b c d : α
⊢ bit0 a < bit0 b ↔ a < b
Theorem: Pmf.toOuterMeasure_bindOnSupport_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp only [toOuterMeasure_apply, Set.indicator_apply, bindOnSupport_apply]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.144355
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
⊢ ↑(toOuterMeasure (bindOnSupport p f)) s = ∑' (a : α), ↑p a * if h : ↑p a = 0 then 0 else ↑(toOuterMeasure (f a h)) s

tactic: calc
  (∑' b, ite (b ∈ s) (∑' a, p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0) =
      ∑' (b) (a), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    tsum_congr fun b => by split_ifs with hbs <;> simp only [eq_self_iff_true, tsum_zero]
  _ = ∑' (a) (b), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    ENNReal.tsum_comm
  _ = ∑' a, p a * ∑' b, ite (b ∈ s) (dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    (tsum_congr fun a => by simp only [← ENNReal.tsum_mul_left, mul_ite, MulZeroClass.mul_zero])
  _ = ∑' a, p a * dite (p a = 0) (fun h => 0) fun h => ∑' b, ite (b ∈ s) (f a h b) 0 :=
    tsum_congr fun a => by split_ifs with ha <;> simp only [ite_self, tsum_zero, eq_self_iff_true]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.144355
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
⊢ (∑' (x : β), if x ∈ s then ∑' (a : α), ↑p a * if h : ↑p a = 0 then 0 else ↑(f a (_ : ¬↑p a = 0)) x else 0) =
    ∑' (a : α), ↑p a * if h : ↑p a = 0 then 0 else ∑' (x : β), if x ∈ s then ↑(f a (_ : ¬↑p a = 0)) x else 0

tactic: split_ifs with hbs <;> simp only [eq_self_iff_true, tsum_zero]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.144355
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
b : β
⊢ (if b ∈ s then ∑' (a : α), ↑p a * if h : ↑p a = 0 then 0 else ↑(f a h) b else 0) =
    ∑' (a : α), if b ∈ s then ↑p a * if h : ↑p a = 0 then 0 else ↑(f a h) b else 0

tactic: simp only [← ENNReal.tsum_mul_left, mul_ite, MulZeroClass.mul_zero]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.144355
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
a : α
⊢ (∑' (b : β), if b ∈ s then ↑p a * if h : ↑p a = 0 then 0 else ↑(f a h) b else 0) =
    ↑p a * ∑' (b : β), if b ∈ s then if h : ↑p a = 0 then 0 else ↑(f a h) b else 0

tactic: split_ifs with ha <;> simp only [ite_self, tsum_zero, eq_self_iff_true]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.144355
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
a : α
⊢ (↑p a * ∑' (b : β), if b ∈ s then if h : ↑p a = 0 then 0 else ↑(f a h) b else 0) =
    ↑p a * if h : ↑p a = 0 then 0 else ∑' (b : β), if b ∈ s then ↑(f a h) b else 0
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.mk
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: let e := sq.flip.isoPullback
state_before: C : Type u
inst✝² : Category C
D : Type ?u.19471
inst✝¹ : Category D
P : MorphismProperty C
inst✝ : HasPullbacks C
hP₁ : RespectsIso P
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P pullback.fst
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
⊢ P g'

tactic: rw [← hP₁.cancel_left_isIso e.inv, sq.flip.isoPullback_inv_fst]
state_before: C : Type u
inst✝² : Category C
D : Type ?u.19471
inst✝¹ : Category D
P : MorphismProperty C
inst✝ : HasPullbacks C
hP₁ : RespectsIso P
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P pullback.fst
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := IsPullback.isoPullback (_ : IsPullback g' f' f g)
⊢ P g'

tactic: exact hP₂ _ _ _ f g hg
state_before: C : Type u
inst✝² : Category C
D : Type ?u.19471
inst✝¹ : Category D
P : MorphismProperty C
inst✝ : HasPullbacks C
hP₁ : RespectsIso P
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P pullback.fst
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := IsPullback.isoPullback (_ : IsPullback g' f' f g)
⊢ P pullback.fst
Theorem: imp_of_if_neg
File: Mathlib/Init/Logic.lean

tactic: have := if_neg hnc ▸ h
state_before: a b c✝ d : Prop
p : ?m.28021
c t e : Prop
inst✝ : Decidable c
h : if c then t else e
hnc : ¬c
⊢ e

tactic: exact this
state_before: a b c✝ d : Prop
p : ?m.28021
c t e : Prop
inst✝ : Decidable c
h : if c then t else e
hnc : ¬c
this : e
⊢ e