tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: refine' (mem_split_iff'.1 h₁).resolve_right fun H => _
state_before: ι : Type u_1
M : Type ?u.37412
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
⊢ ↑J = ↑I ∩ {y | y i ≤ x}

tactic: rw [← Box.mem_coe, H] at h₂
state_before: ι : Type u_1
M : Type ?u.37412
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False

tactic: exact h₃.not_lt h₂.2
state_before: ι : Type u_1
M : Type ?u.37412
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ ↑I ∩ {y | x < y i}
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
Theorem: Fin.one_mul
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.mul_comm, Fin.mul_one]
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ 1 * k = k
Theorem: List.modifyNth_eq_set_get
File: Std/Data/List/Lemmas.lean

tactic: rw [modifyNth_eq_set_get?, get?_eq_get h]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < length l
⊢ modifyNth f n l = set l n (f (get l { val := n, isLt := h }))

tactic: rfl
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < length l
⊢ Option.getD ((fun a => set l n (f a)) <$> some (get l { val := n, isLt := h })) l =
    set l n (f (get l { val := n, isLt := h }))
Theorem: MeasurableEquiv.map_ae
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2927971
δ : Type ?u.2927974
ι : Type ?u.2927977
R : Type ?u.2927980
R' : Type ?u.2927983
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
f : α ≃ᵐ β
μ : MeasureTheory.Measure α
⊢ Filter.map (↑f) (ae μ) = ae (Measure.map (↑f) μ)

tactic: simp_rw [mem_map, mem_ae_iff, ← preimage_compl, f.map_apply]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.2927971
δ : Type ?u.2927974
ι : Type ?u.2927977
R : Type ?u.2927980
R' : Type ?u.2927983
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
f : α ≃ᵐ β
μ : MeasureTheory.Measure α
s : Set β
⊢ s ∈ Filter.map (↑f) (ae μ) ↔ s ∈ ae (Measure.map (↑f) μ)
Theorem: MvPolynomial.cardinal_mk_le_max
File: Mathlib/Data/MvPolynomial/Cardinal.lean

tactic: rw [lift_id, lift_id]
state_before: σ R : Type u
inst✝ : CommSemiring R
⊢ max (max (lift (#R)) (lift (#σ))) ℵ₀ ≤ max (max (#R) (#σ)) ℵ₀
Theorem: Set.prod_univ_range_eq
File: Mathlib/Data/Set/Prod.lean

tactic: simp [range]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.66990
δ : Type u_2
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
m₂ : β → δ
⊢ ∀ (x : α × δ), x ∈ univ ×ˢ range m₂ ↔ x ∈ range fun p => (p.fst, m₂ p.snd)
Theorem: MeasureTheory.indicatorConst_empty
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp
state_before: α : Type ?u.692725
E : Type ?u.692728
F : Type ?u.692731
G : Type ?u.692734
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
⊢ ↑↑μ ∅ ≠ ⊤

tactic: rw [Lp.eq_zero_iff_ae_eq_zero]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.692731
G : Type ?u.692734
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
⊢ indicatorConstLp p (_ : MeasurableSet ∅) (_ : ↑↑μ ∅ ≠ ⊤) c = 0

tactic: convert indicatorConstLp_coeFn (E := E)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.692731
G : Type ?u.692734
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
⊢ ↑↑(indicatorConstLp p (_ : MeasurableSet ∅) (_ : ↑↑μ ∅ ≠ ⊤) c) =ᵐ[μ] 0

tactic: simp [Set.indicator_empty']
state_before: case h.e'_5
α : Type u_1
E : Type u_2
F : Type ?u.692731
G : Type ?u.692734
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
⊢ 0 = Set.indicator ∅ fun x => c

tactic: rfl
state_before: case h.e'_5
α : Type u_1
E : Type u_2
F : Type ?u.692731
G : Type ?u.692734
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
⊢ 0 = fun x => 0
Theorem: Multiset.card_Ico
File: Mathlib/Data/Multiset/Interval.lean

tactic: rw [card_Ico_eq_card_Icc_sub_one, card_Icc]
state_before: α : Type u_1
β : α → Type ?u.45300
inst✝ : DecidableEq α
f g : Multiset α
⊢ Finset.card (Finset.Ico f g) = ∏ i in toFinset f ∪ toFinset g, (count i g + 1 - count i f) - 1
Theorem: Qpf.Fix.mk_dest
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: change (Fix.mk ∘ Fix.dest) x = id x
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x : Fix F
⊢ mk (dest x) = x

tactic: apply Fix.ind_rec (mk ∘ dest) id
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x : Fix F
⊢ (mk ∘ dest) x = id x

tactic: intro x
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x : Fix F
⊢ ∀ (x : F (Fix F)), (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)

tactic: rw [Function.comp_apply, id_eq, Fix.dest, Fix.rec_eq, id_map, comp_map]
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x✝ : Fix F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)

tactic: intro h
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x✝ : Fix F
x : F (Fix F)
⊢ mk <$> rec (Functor.map mk) <$> x = x → mk (mk <$> rec (Functor.map mk) <$> x) = mk x

tactic: rw [h]
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x✝ : Fix F
x : F (Fix F)
h : mk <$> rec (Functor.map mk) <$> x = x
⊢ mk (mk <$> rec (Functor.map mk) <$> x) = mk x
Theorem: Complex.normSq_eq_conj_mul_self
File: Mathlib/Data/Complex/Basic.lean

tactic: ext <;> simp [normSq, mul_comm, ofReal']
state_before: z : ℂ
⊢ ↑(↑normSq z) = ↑(starRingEnd ℂ) z * z
Theorem: ManyOneDegree.of_eq_of
File: Mathlib/Computability/Reduce.lean

tactic: rw [of, of, Quotient.eq'']
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p : α → Prop
q : β → Prop
⊢ of p = of q ↔ ManyOneEquiv p q

tactic: unfold Setoid.r
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p : α → Prop
q : β → Prop
⊢ Setoid.r (toNat p) (toNat q) ↔ ManyOneEquiv p q

tactic: simp
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p : α → Prop
q : β → Prop
⊢ { r := ManyOneEquiv, iseqv := proof_1 }.1 (toNat p) (toNat q) ↔ ManyOneEquiv p q
Theorem: Function.Commute.right_bijOn_fixedPoints_comp
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: simpa only [h.comp_eq] using bijOn_fixedPoints_comp f g
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n k : ℕ
e : Perm α
h : Commute f g
⊢ Set.BijOn g (fixedPoints (f ∘ g)) (fixedPoints (f ∘ g))
Theorem: gramSchmidtOrthonormalBasis_apply_of_orthogonal
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: have H : gramSchmidtNormed 𝕜 f i = (‖f i‖⁻¹ : 𝕜) • f i := by
  rw [gramSchmidtNormed, gramSchmidt_of_orthogonal 𝕜 hf]
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f✝ f : ι → E
hf : Pairwise fun i j => inner (f i) (f j) = 0
i : ι
hi : f i ≠ 0
⊢ ↑(gramSchmidtOrthonormalBasis h f) i = (↑‖f i‖)⁻¹ • f i

tactic: rw [gramSchmidtOrthonormalBasis_apply h, H]
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f✝ f : ι → E
hf : Pairwise fun i j => inner (f i) (f j) = 0
i : ι
hi : f i ≠ 0
H : gramSchmidtNormed 𝕜 f i = (↑‖f i‖)⁻¹ • f i
⊢ ↑(gramSchmidtOrthonormalBasis h f) i = (↑‖f i‖)⁻¹ • f i

tactic: simpa [H] using hi
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f✝ f : ι → E
hf : Pairwise fun i j => inner (f i) (f j) = 0
i : ι
hi : f i ≠ 0
H : gramSchmidtNormed 𝕜 f i = (↑‖f i‖)⁻¹ • f i
⊢ gramSchmidtNormed 𝕜 f i ≠ 0

tactic: rw [gramSchmidtNormed, gramSchmidt_of_orthogonal 𝕜 hf]
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f✝ f : ι → E
hf : Pairwise fun i j => inner (f i) (f j) = 0
i : ι
hi : f i ≠ 0
⊢ gramSchmidtNormed 𝕜 f i = (↑‖f i‖)⁻¹ • f i
Theorem: SimpleGraph.not_mem_neighborFinset_self
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp
state_before: ι : Sort ?u.267083
𝕜 : Type ?u.267086
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝ : Fintype ↑(neighborSet G v)
⊢ ¬v ∈ neighborFinset G v
Theorem: Int.emod_add_cancel_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.add_comm, Int.add_comm i, emod_add_cancel_right]
state_before: m n k i : Int
⊢ (i + m) % n = (i + k) % n ↔ m % n = k % n
Theorem: differentiable_const_add_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa using h.const_add (-c)
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.280459
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.280554
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
c : F
h : Differentiable 𝕜 fun y => c + f y
⊢ Differentiable 𝕜 f
Theorem: EReal.le_neg_of_le_neg
File: Mathlib/Data/Real/EReal.lean

tactic: rwa [← neg_neg b, EReal.neg_le, neg_neg]
state_before: a b : EReal
h : a ≤ -b
⊢ b ≤ -a
Theorem: FirstOrder.Language.BoundedFormula.realize_ex
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [BoundedFormula.ex, realize_not, realize_all, not_forall]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.69331
P : Type ?u.69334
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (∃'θ) v xs ↔ ∃ a, Realize θ v (snoc xs a)

tactic: simp_rw [realize_not, Classical.not_not]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.69331
P : Type ?u.69334
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ (∃ x, ¬Realize (∼θ) v (snoc xs x)) ↔ ∃ a, Realize θ v (snoc xs a)
Theorem: MeasureTheory.memℒp_two_iff_integrable_sq
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: convert memℒp_two_iff_integrable_sq_norm hf using 3
state_before: α : Type u_1
F : Type ?u.18682
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → ℝ
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 ↔ Integrable fun x => f x ^ 2

tactic: simp
state_before: case h.e'_2.h.e'_5.h
α : Type u_1
F : Type ?u.18682
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → ℝ
hf : AEStronglyMeasurable f μ
x✝ : α
⊢ f x✝ ^ 2 = ‖f x✝‖ ^ 2
Theorem: HasDerivAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hx : f x ≠ 0
⊢ HasDerivAt (fun y => Real.log (f y)) (f' / f x) x

tactic: exact hf.log hx
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) Set.univ x
Theorem: MeasureTheory.SimpleFunc.restrict_const_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [restrict_lintegral_eq_lintegral_restrict _ hs, const_lintegral_restrict]
state_before: α : Type u_1
β : Type ?u.897363
γ : Type ?u.897366
δ : Type ?u.897369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ lintegral (restrict (const α c) s) μ = c * ↑↑μ s
Theorem: IsCompl.disjoint_left_iff
File: Mathlib/Order/Disjoint.lean

tactic: rw [disjoint_iff]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z : α
h : IsCompl y z
⊢ Disjoint x y ↔ x ≤ z

tactic: exact h.inf_left_eq_bot_iff
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z : α
h : IsCompl y z
⊢ x ⊓ y = ⊥ ↔ x ≤ z
Theorem: MeasureTheory.withDensity_add_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.1757811
γ : Type ?u.1757814
δ : Type ?u.1757817
m✝ : MeasurableSpace α
μ✝ ν✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ withDensity (μ + ν) f = withDensity μ f + withDensity ν f

tactic: simp only [withDensity_apply f hs, restrict_add, lintegral_add_measure, Measure.add_apply]
state_before: case h
α : Type u_1
β : Type ?u.1757811
γ : Type ?u.1757814
δ : Type ?u.1757817
m✝ : MeasurableSpace α
μ✝ ν✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ ↑↑(withDensity (μ + ν) f) s = ↑↑(withDensity μ f + withDensity ν f) s
Theorem: FractionalIdeal.mul_le
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J K : FractionalIdeal S P
⊢ I * J ≤ K ↔ ∀ (i : P), i ∈ I → ∀ (j : P), j ∈ J → i * j ∈ K

tactic: exact Submodule.mul_le
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J K : FractionalIdeal S P
⊢ { val := ↑I * ↑J, property := (_ : IsFractional S (↑I * ↑J)) } ≤ K ↔ ∀ (i : P), i ∈ I → ∀ (j : P), j ∈ J → i * j ∈ K
Theorem: mem_nhdsSet_empty
File: Mathlib/Topology/NhdsSet.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.12346
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
⊢ s ∈ 𝓝ˢ ∅
Theorem: Int.cast_eq_one
File: Mathlib/Data/Int/CharZero.lean

tactic: rw [← cast_one, cast_inj]
state_before: α : Type u_1
inst✝¹ : AddGroupWithOne α
inst✝ : CharZero α
n : ℤ
⊢ ↑n = 1 ↔ n = 1
Theorem: finprod_mem_mulSupport
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← mem_mulSupport, finprod_eq_mulIndicator_apply, mulIndicator_mulSupport]
state_before: α : Type ?u.174780
β : Type ?u.174783
ι : Type ?u.174786
G : Type ?u.174789
M : Type u_1
N : Type ?u.174795
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
⊢ (∏ᶠ (_ : f a ≠ 1), f a) = f a
Theorem: Matrix.IsHermitian.inv
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: simp [IsHermitian, conjTranspose_nonsing_inv, hA.eq]
state_before: α : Type u_2
β : Type ?u.46849
m : Type u_1
n : Type ?u.46855
A✝ : Matrix n n α
inst✝³ : CommRing α
inst✝² : StarRing α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m α
hA : IsHermitian A
⊢ IsHermitian A⁻¹
Theorem: CategoryTheory.IsFiltered.coeq₃_condition₂
File: Mathlib/CategoryTheory/Filtered.lean

tactic: dsimp [coeq₃Hom]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ g ≫ coeq₃Hom f g h = h ≫ coeq₃Hom f g h

tactic: slice_lhs 2 4 => rw [← Category.assoc, coeq_condition _ _]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ g ≫
      coeqHom f g ≫
        leftToMax (coeq f g) (coeq g h) ≫
          coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) =
    h ≫
      coeqHom f g ≫
        leftToMax (coeq f g) (coeq g h) ≫
          coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h))

tactic: slice_rhs 2 4 => rw [← Category.assoc, coeq_condition _ _]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ g ≫
      (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) ≫
        coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) =
    h ≫
      coeqHom f g ≫
        leftToMax (coeq f g) (coeq g h) ≫
          coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h))

tactic: slice_lhs 1 3 => rw [← Category.assoc, coeq_condition _ _]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ g ≫
      (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) ≫
        coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) =
    h ≫
      (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) ≫
        coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h))

tactic: simp only [Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ ((h ≫ coeqHom g h) ≫ rightToMax (coeq f g) (coeq g h)) ≫
      coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) =
    h ≫
      (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h)) ≫
        coeqHom (coeqHom f g ≫ leftToMax (coeq f g) (coeq g h)) (coeqHom g h ≫ rightToMax (coeq f g) (coeq g h))
Theorem: inducing_of_inducing_compose
File: Mathlib/Topology/Maps.lean

tactic: rwa [← continuous_iff_le_induced]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.717
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hf : Continuous f
hg : Continuous g
hgf : Inducing (g ∘ f)
⊢ inst✝³ ≤ induced f inst✝²

tactic: rw [hgf.induced, ← induced_compose]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.717
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hf : Continuous f
hg : Continuous g
hgf : Inducing (g ∘ f)
⊢ induced f inst✝² ≤ inst✝³

tactic: exact induced_mono hg.le_induced
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.717
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hf : Continuous f
hg : Continuous g
hgf : Inducing (g ∘ f)
⊢ induced f inst✝² ≤ induced f (induced g inst✝¹)
Theorem: CategoryTheory.Limits.Fork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← t.app_one_eq_ι_comp_left, ← t.app_one_eq_ι_comp_right]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
t : Fork f g
⊢ ι t ≫ f = ι t ≫ g
Theorem: Int.mul_lt_mul_of_neg_left
File: Std/Data/Int/Lemmas.lean

tactic: rwa [← Int.neg_mul_eq_neg_mul, ← Int.neg_mul_eq_neg_mul] at this
state_before: a b c : Int
h : b < a
hc : c < 0
this✝ : -c > 0
this : -c * b < -c * a
⊢ -(c * b) < -(c * a)
Theorem: IsComplete.completeSpace_coe
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simp [hs]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set α
hs : IsComplete s
⊢ IsComplete (Subtype.val '' univ)
Theorem: DFA.toNFA_evalFrom_match
File: Mathlib/Computability/NFA.lean

tactic: change List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ NFA.evalFrom (toNFA M) {start} s = {evalFrom M start s}

tactic: induction' s with a s ih generalizing start
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ List.foldl (NFA.stepSet (toNFA M)) {start} s = {List.foldl M.step start s}

tactic: tauto
state_before: case nil
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start✝ start : σ
⊢ List.foldl (NFA.stepSet (toNFA M)) {start} [] = {List.foldl M.step start []}

tactic: rw [List.foldl, List.foldl,
  show M.toNFA.stepSet {start} a = {M.step start a} by simp [NFA.stepSet] ]
state_before: case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start✝ : σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl (NFA.stepSet (toNFA M)) {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl (NFA.stepSet (toNFA M)) {start} (a :: s) = {List.foldl M.step start (a :: s)}

tactic: tauto
state_before: case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start✝ : σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl (NFA.stepSet (toNFA M)) {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl (NFA.stepSet (toNFA M)) {step M start a} s = {List.foldl M.step (step M start a) s}

tactic: simp [NFA.stepSet]
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start✝ : σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl (NFA.stepSet (toNFA M)) {start} s = {List.foldl M.step start s}
start : σ
⊢ NFA.stepSet (toNFA M) {start} a = {step M start a}
Theorem: Rat.le_antisymm
File: Mathlib/Data/Rat/Order.lean

tactic: rw [Rat.le_iff_Nonneg] at hab hba
state_before: a✝ b✝ c a b : ℚ
hab : a ≤ b
hba : b ≤ a
⊢ a = b

tactic: rw [sub_eq_add_neg] at hba
state_before: a✝ b✝ c a b : ℚ
hab : Rat.Nonneg (b - a)
hba : Rat.Nonneg (a - b)
⊢ a = b

tactic: rw [←neg_sub, sub_eq_add_neg] at hab
state_before: a✝ b✝ c a b : ℚ
hab : Rat.Nonneg (b - a)
hba : Rat.Nonneg (a + -b)
⊢ a = b

tactic: have := eq_neg_of_add_eq_zero_left (Rat.nonneg_antisymm hba hab)
state_before: a✝ b✝ c a b : ℚ
hab : Rat.Nonneg (-(a + -b))
hba : Rat.Nonneg (a + -b)
⊢ a = b

tactic: rwa [neg_neg] at this
state_before: a✝ b✝ c a b : ℚ
hab : Rat.Nonneg (-(a + -b))
hba : Rat.Nonneg (a + -b)
this : a = - -b
⊢ a = b
Theorem: LowerSet.mem_iSup_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← SetLike.mem_coe, coe_iSup]
state_before: α : Type u_1
β : Type ?u.76667
γ : Type ?u.76670
ι : Sort u_2
κ : ι → Sort ?u.76678
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ (a ∈ ⨆ (i : ι), f i) ↔ ∃ i, a ∈ f i

tactic: exact mem_iUnion
state_before: α : Type u_1
β : Type ?u.76667
γ : Type ?u.76670
ι : Sort u_2
κ : ι → Sort ?u.76678
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ (a ∈ ⋃ (i : ι), ↑(f i)) ↔ ∃ i, a ∈ f i