1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: EReal.toReal_mul
File: Mathlib/Data/Real/EReal.lean

tactic: induction x, y using induction₂_symm with
| top_zero | zero_bot | top_top | top_bot | bot_bot => simp
| symm h => rwa [mul_comm, EReal.mul_comm]
| coe_coe => norm_cast
| top_pos _ h => simp [top_mul_coe_of_pos h]
| top_neg _ h => simp [top_mul_coe_of_neg h]
| pos_bot _ h => simp [coe_mul_bot_of_pos h]
| neg_bot _ h => simp [coe_mul_bot_of_neg h]
state_before: x y : EReal
⊢ (x * y).toReal = x.toReal * y.toReal
state_after: no goals

tactic: simp
state_before: case bot_bot

⊢ (⊥ * ⊥).toReal = ⊥.toReal * ⊥.toReal
state_after: no goals

tactic: rwa [mul_comm, EReal.mul_comm]
state_before: case symm
x✝ y✝ : EReal
h : (x✝ * y✝).toReal = x✝.toReal * y✝.toReal
⊢ (y✝ * x✝).toReal = y✝.toReal * x✝.toReal
state_after: no goals

tactic: norm_cast
state_before: case coe_coe
x✝ y✝ : ℝ
⊢ (↑x✝ * ↑y✝).toReal = (↑x✝).toReal * (↑y✝).toReal
state_after: no goals

tactic: simp [top_mul_coe_of_pos h]
state_before: case top_pos
x✝ : ℝ
h : 0 < x✝
⊢ (⊤ * ↑x✝).toReal = ⊤.toReal * (↑x✝).toReal
state_after: no goals

tactic: simp [top_mul_coe_of_neg h]
state_before: case top_neg
x✝ : ℝ
h : x✝ < 0
⊢ (⊤ * ↑x✝).toReal = ⊤.toReal * (↑x✝).toReal
state_after: no goals

tactic: simp [coe_mul_bot_of_pos h]
state_before: case pos_bot
x✝ : ℝ
h : 0 < x✝
⊢ (↑x✝ * ⊥).toReal = (↑x✝).toReal * ⊥.toReal
state_after: no goals

tactic: simp [coe_mul_bot_of_neg h]
state_before: case neg_bot
x✝ : ℝ
h : x✝ < 0
⊢ (↑x✝ * ⊥).toReal = (↑x✝).toReal * ⊥.toReal
state_after: no goals
Theorem: multiplicity.multiplicity_sub_of_gt
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [sub_eq_add_neg, multiplicity_add_of_gt] <;> rw [multiplicity.neg]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p (a - b) = multiplicity p b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p b < multiplicity p a

tactic: assumption
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p b < multiplicity p a
state_after: no goals
Theorem: MulHom.map_srange
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

tactic: simpa only [srange_eq_map] using (⊤ : Subsemigroup M).map_map g f
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
g : N →ₙ* P
f : M →ₙ* N
⊢ map g f.srange = (g.comp f).srange
state_after: no goals
Theorem: NonUnitalNonAssocCommSemiring.toNonUnitalNonAssocSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro ⟨⟩ ⟨⟩ _
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalNonAssocSemiring R)
state_after: case mk.mk
R : Type u
toNonUnitalNonAssocSemiring✝¹ : NonUnitalNonAssocSemiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalNonAssocSemiring✝ : NonUnitalNonAssocSemiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝

tactic: congr
state_before: case mk.mk
R : Type u
toNonUnitalNonAssocSemiring✝¹ : NonUnitalNonAssocSemiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalNonAssocSemiring✝ : NonUnitalNonAssocSemiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝
state_after: no goals
Theorem: CategoryTheory.Limits.coprod.pentagon
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ : C
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
W X Y Z : C
⊢ map (associator W X Y).hom (𝟙 Z) ≫ (associator W (X ⨿ Y) Z).hom ≫ map (𝟙 W) (associator X Y Z).hom =
    (associator (W ⨿ X) Y Z).hom ≫ (associator W X (Y ⨿ Z)).hom
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.size_tail
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
h : s.NoSibling
⊢ (tail le s).size = s.size - 1
state_after: α : Type u_1
le : α → α → Bool
s : Heap α
h : s.NoSibling
⊢ ((tail? le s).getD nil).size = s.size - 1

tactic: match eq : s.tail? le with
| none => cases s with cases eq | nil => rfl
| some tl => simp [Heap.size_tail? h eq]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
h : s.NoSibling
⊢ ((tail? le s).getD nil).size = s.size - 1
state_after: no goals

tactic: cases s with cases eq | nil => rfl
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
h : s.NoSibling
eq : tail? le s = none
⊢ (none.getD nil).size = s.size - 1
state_after: no goals

tactic: rfl
state_before: case nil.refl
α : Type u_1
le : α → α → Bool
h : nil.NoSibling
⊢ (none.getD nil).size = nil.size - 1
state_after: no goals

tactic: simp [Heap.size_tail? h eq]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
h : s.NoSibling
tl : Heap α
eq : tail? le s = some tl
⊢ ((some tl).getD nil).size = s.size - 1
state_after: no goals
Theorem: Polynomial.eval_natCast_mul
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [← C_eq_natCast, eval_C_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
n : ℕ
⊢ eval x (↑n * p) = ↑n * eval x p
state_after: no goals
Theorem: ProbabilityTheory.setLIntegral_condKernel
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: conv_rhs => rw [← kernel.compProd_fst_condKernel κ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in t, f (b, ω) ∂(kernel.condKernel κ) (a, b) ∂(kernel.fst κ) a =
    ∫⁻ (x : β × Ω) in s ×ˢ t, f x ∂κ a
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in t, f (b, ω) ∂(kernel.condKernel κ) (a, b) ∂(kernel.fst κ) a =
    ∫⁻ (x : β × Ω) in s ×ˢ t, f x ∂(kernel.fst κ ⊗ₖ kernel.condKernel κ) a

tactic: rw [kernel.setLIntegral_compProd _ _ _ hf hs ht]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in t, f (b, ω) ∂(kernel.condKernel κ) (a, b) ∂(kernel.fst κ) a =
    ∫⁻ (x : β × Ω) in s ×ˢ t, f x ∂(kernel.fst κ ⊗ₖ kernel.condKernel κ) a
state_after: no goals
Theorem: setOf_liouville_eq_irrational_inter_iInter_iUnion
File: Mathlib/NumberTheory/Liouville/Residual.lean

tactic: refine Subset.antisymm ?_ ?_
state_before: ⊢ {x | Liouville x} = {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
state_after: case refine_1

⊢ {x | Liouville x} ⊆ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

case refine_2

⊢ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ {x | Liouville x}

tactic: refine subset_inter (fun x hx => hx.irrational) ?_
state_before: case refine_1

⊢ {x | Liouville x} ⊆ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
state_after: case refine_1

⊢ {x | Liouville x} ⊆ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: rw [setOf_liouville_eq_iInter_iUnion]
state_before: case refine_1

⊢ {x | Liouville x} ⊆ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
state_after: case refine_1

⊢ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b} ⊆
    ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: exact iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun _hb => diff_subset
state_before: case refine_1

⊢ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b} ⊆
    ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
state_after: no goals

tactic: simp only [inter_iInter, inter_iUnion, setOf_liouville_eq_iInter_iUnion]
state_before: case refine_2

⊢ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ {x | Liouville x}
state_after: case refine_2

⊢ ⋂ i, ⋃ i_1, ⋃ i_2, ⋃ (_ : 1 < i_2), {x | Irrational x} ∩ ball (↑i_1 / ↑i_2) (1 / ↑i_2 ^ i) ⊆
    ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: refine iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun hb => ?_
state_before: case refine_2

⊢ ⋂ i, ⋃ i_1, ⋃ i_2, ⋃ (_ : 1 < i_2), {x | Irrational x} ∩ ball (↑i_1 / ↑i_2) (1 / ↑i_2 ^ i) ⊆
    ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
state_after: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ {x | Irrational x} ∩ ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: rw [inter_comm]
state_before: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ {x | Irrational x} ∩ ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
state_after: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ ball (↑a / ↑b) (1 / ↑b ^ n) ∩ {x | Irrational x} ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: exact diff_subset_diff Subset.rfl (singleton_subset_iff.2 ⟨a / b, by norm_cast⟩)
state_before: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ ball (↑a / ↑b) (1 / ↑b ^ n) ∩ {x | Irrational x} ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
state_after: no goals

tactic: norm_cast
state_before: n : ℕ
a b : ℤ
hb : 1 < b
⊢ ↑(↑a / ↑b) = ↑a / ↑b
state_after: no goals
Theorem: CategoryTheory.Iso.refl_trans
File: Mathlib/CategoryTheory/Iso.lean

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
⊢ refl X ≪≫ α = α
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
⊢ (refl X ≪≫ α).hom = α.hom

tactic: apply Category.id_comp
state_before: case w
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
⊢ (refl X ≪≫ α).hom = α.hom
state_after: no goals
Theorem: Ordinal.enumOrd_def
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [enumOrd_def']
state_before: S : Set Ordinal.{u}
o : Ordinal.{u}
⊢ enumOrd S o = sInf (S ∩ {b | ∀ c < o, enumOrd S c < b})
state_after: S : Set Ordinal.{u}
o : Ordinal.{u}
⊢ sInf (S ∩ Ici (o.blsub fun a x => enumOrd S a)) = sInf (S ∩ {b | ∀ c < o, enumOrd S c < b})

tactic: congr
state_before: S : Set Ordinal.{u}
o : Ordinal.{u}
⊢ sInf (S ∩ Ici (o.blsub fun a x => enumOrd S a)) = sInf (S ∩ {b | ∀ c < o, enumOrd S c < b})
state_after: case e_a.e_a
S : Set Ordinal.{u}
o : Ordinal.{u}
⊢ Ici (o.blsub fun a x => enumOrd S a) = {b | ∀ c < o, enumOrd S c < b}

tactic: ext
state_before: case e_a.e_a
S : Set Ordinal.{u}
o : Ordinal.{u}
⊢ Ici (o.blsub fun a x => enumOrd S a) = {b | ∀ c < o, enumOrd S c < b}
state_after: case e_a.e_a.h
S : Set Ordinal.{u}
o x✝ : Ordinal.{u}
⊢ x✝ ∈ Ici (o.blsub fun a x => enumOrd S a) ↔ x✝ ∈ {b | ∀ c < o, enumOrd S c < b}

tactic: exact ⟨fun h a hao => (lt_blsub.{u, u} _ _ hao).trans_le h, blsub_le⟩
state_before: case e_a.e_a.h
S : Set Ordinal.{u}
o x✝ : Ordinal.{u}
⊢ x✝ ∈ Ici (o.blsub fun a x => enumOrd S a) ↔ x✝ ∈ {b | ∀ c < o, enumOrd S c < b}
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.whiskerRight_id_symm
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
f : X ⟶ Y
⊢ f = (ρ_ X).inv ≫ f ▷ 𝟙_ C ≫ (ρ_ Y).hom
state_after: no goals
Theorem: hasFDerivAt_polarCoord_symm
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

tactic: rw [Matrix.toLin_finTwoProd_toContinuousLinearMap]
state_before: p : ℝ × ℝ
⊢ HasFDerivAt (↑polarCoord.symm)
    (LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]])))
    p
state_after: p : ℝ × ℝ
⊢ HasFDerivAt (↑polarCoord.symm)
    ((cos p.2 • ContinuousLinearMap.fst ℝ ℝ ℝ + (-p.1 * sin p.2) • ContinuousLinearMap.snd ℝ ℝ ℝ).prod
      (sin p.2 • ContinuousLinearMap.fst ℝ ℝ ℝ + (p.1 * cos p.2) • ContinuousLinearMap.snd ℝ ℝ ℝ))
    p

tactic: convert HasFDerivAt.prod (𝕜 := ℝ)
  (hasFDerivAt_fst.mul ((hasDerivAt_cos p.2).comp_hasFDerivAt p hasFDerivAt_snd))
  (hasFDerivAt_fst.mul ((hasDerivAt_sin p.2).comp_hasFDerivAt p hasFDerivAt_snd)) using 2 <;>
simp [smul_smul, add_comm, neg_mul, smul_neg, neg_smul _ (ContinuousLinearMap.snd ℝ ℝ ℝ)]
state_before: p : ℝ × ℝ
⊢ HasFDerivAt (↑polarCoord.symm)
    ((cos p.2 • ContinuousLinearMap.fst ℝ ℝ ℝ + (-p.1 * sin p.2) • ContinuousLinearMap.snd ℝ ℝ ℝ).prod
      (sin p.2 • ContinuousLinearMap.fst ℝ ℝ ℝ + (p.1 * cos p.2) • ContinuousLinearMap.snd ℝ ℝ ℝ))
    p
state_after: no goals
Theorem: Batteries.RBNode.RedRed.balance2
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: simpa using h.reverse
state_before: α : Type u_1
c : RBColor
n : Nat
p : Prop
l : RBNode α
v : α
r : RBNode α
hl : l.Balanced c n
hr : RedRed p r n
x✝ : RBColor
h : (r.reverse.balance1 v l.reverse).Balanced x✝ (n + 1)
⊢ (l.balance2 v r).Balanced x✝ (n + 1)
state_after: no goals
Theorem: Finset.coe_eq_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_singleton, coe_inj]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ : Finset α
a✝ b : α
s : Finset α
a : α
⊢ ↑s = {a} ↔ s = {a}
state_after: no goals
Theorem: Matrix.updateRow_apply
File: Mathlib/Data/Matrix/RowCol.lean

tactic: by_cases h : i' = i
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j
state_after: case pos
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j

case neg
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : ¬i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j

tactic: rw [h, updateRow_self, if_pos rfl]
state_before: case pos
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j
state_after: no goals

tactic: rw [updateRow_ne h, if_neg h]
state_before: case neg
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : ¬i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j
state_after: no goals
Theorem: Nat.bit_mod_two_eq_one_iff
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [bit_mod_two]
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ bit a x % 2 = 1 ↔ a = true
state_after: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 1 else 0) = 1 ↔ a = true

tactic: split_ifs <;> simp_all
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 1 else 0) = 1 ↔ a = true
state_after: no goals
Theorem: exists_linearIndependent
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: obtain ⟨b, hb₁, -, hb₂, hb₃⟩ :=
  exists_linearIndependent_extension (linearIndependent_empty K V) (Set.empty_subset t)
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
state_after: case intro.intro.intro.intro
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
b : Set V
hb₁ : b ⊆ t
hb₂ : t ⊆ ↑(span K b)
hb₃ : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val

tactic: exact ⟨b, hb₁, (span_eq_of_le _ hb₂ (Submodule.span_mono hb₁)).symm, hb₃⟩
state_before: case intro.intro.intro.intro
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
b : Set V
hb₁ : b ⊆ t
hb₂ : t ⊆ ↑(span K b)
hb₃ : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
state_after: no goals
Theorem: Submodule.mem_iSup
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [← span_singleton_le_iff_mem, le_iSup_iff]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
m : M
⊢ m ∈ ⨆ i, p i ↔ ∀ (N : Submodule R M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
m : M
⊢ (∀ (b : Submodule R M), (∀ (i : ι), p i ≤ b) → span R {m} ≤ b) ↔ ∀ (N : Submodule R M), (∀ (i : ι), p i ≤ N) → m ∈ N

tactic: simp only [span_singleton_le_iff_mem]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
m : M
⊢ (∀ (b : Submodule R M), (∀ (i : ι), p i ≤ b) → span R {m} ≤ b) ↔ ∀ (N : Submodule R M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: no goals
Theorem: Finmap.keys_erase_toFinset
File: Mathlib/Data/Finmap.lean

tactic: simp [Finset.erase, keys, AList.erase, keys_kerase]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ ⟦AList.erase a s⟧.keys = ⟦s⟧.keys.erase a
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.matrix_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext
state_before: J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
k : K
⊢ matrix m ≫ π g k = desc fun j => m j k
state_after: case w
J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
k : K
j✝ : J
⊢ ι f j✝ ≫ matrix m ≫ π g k = ι f j✝ ≫ desc fun j => m j k

tactic: simp [biproduct.matrix]
state_before: case w
J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
k : K
j✝ : J
⊢ ι f j✝ ≫ matrix m ≫ π g k = ι f j✝ ≫ desc fun j => m j k
state_after: no goals
Theorem: Set.Definable.mono
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [definable_iff_empty_definable_with_params] at *
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
hAs : A.Definable L s
hAB : A ⊆ B
⊢ B.Definable L s
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
hAs : ∅.Definable (L[[↑A]]) s
hAB : A ⊆ B
⊢ ∅.Definable (L[[↑B]]) s

tactic: exact hAs.map_expansion (L.lhomWithConstantsMap (Set.inclusion hAB))
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
hAs : ∅.Definable (L[[↑A]]) s
hAB : A ⊆ B
⊢ ∅.Definable (L[[↑B]]) s
state_after: no goals
Theorem: List.map_diff
File: Mathlib/Data/List/Basic.lean

tactic: simp only [diff_eq_foldl, foldl_map, map_foldl_erase finj]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
l₁ l₂ : List α
⊢ map f (l₁.diff l₂) = (map f l₁).diff (map f l₂)
state_after: no goals
Theorem: Set.Finite.exists_finset
File: Mathlib/Data/Set/Finite.lean

tactic: cases h.nonempty_fintype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : s.Finite
⊢ ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s
state_after: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : s.Finite
val✝ : Fintype ↑s
⊢ ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s

tactic: exact ⟨s.toFinset, fun _ => mem_toFinset⟩
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : s.Finite
val✝ : Fintype ↑s
⊢ ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.jordanDecomposition_add_withDensity_mutuallySingular
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

tactic: rw [mutuallySingular_ennreal_iff, totalVariation_mutuallySingular_iff,
  VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure] at htμ
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ μ.toENNRealVectorMeasure
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t.toJordanDecomposition.posPart ⟂ₘ μ ∧ t.toJordanDecomposition.negPart ⟂ₘ μ
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)

tactic: exact
  ((JordanDecomposition.mutuallySingular _).add_right
        (htμ.1.mono_ac (refl _) (withDensity_absolutelyContinuous _ _))).add_left
    ((htμ.2.symm.mono_ac (withDensity_absolutelyContinuous _ _) (refl _)).add_right
      (withDensity_ofReal_mutuallySingular hf))
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t.toJordanDecomposition.posPart ⟂ₘ μ ∧ t.toJordanDecomposition.negPart ⟂ₘ μ
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)
state_after: no goals