tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearMap.range_eq_map_coprodSubtypeLEquivOfIsCompl
File: Mathlib/Analysis/NormedSpace/Banach.lean

tactic: rw [coprodSubtypeLEquivOfIsCompl, ContinuousLinearEquiv.coe_ofBijective,
  coe_coprod, LinearMap.coprod_map_prod, Submodule.map_bot, sup_bot_eq, Submodule.map_top]
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
f✝ : E →L[𝕜] F
inst✝² : CompleteSpace F
inst✝¹ : CompleteSpace E
f : E →L[𝕜] F
G : Submodule 𝕜 F
h : IsCompl (LinearMap.range f) G
inst✝ : CompleteSpace { x // x ∈ G }
hker : ker f = ⊥
⊢ LinearMap.range f = Submodule.map (↑↑(coprodSubtypeLEquivOfIsCompl f h hker)) (Submodule.prod ⊤ ⊥)

tactic: rfl
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
f✝ : E →L[𝕜] F
inst✝² : CompleteSpace F
inst✝¹ : CompleteSpace E
f : E →L[𝕜] F
G : Submodule 𝕜 F
h : IsCompl (LinearMap.range f) G
inst✝ : CompleteSpace { x // x ∈ G }
hker : ker f = ⊥
⊢ LinearMap.range f = LinearMap.range ↑f
Theorem: LowerAdjoint.ext
File: Mathlib/Order/Closure.lean

tactic: congr
state_before: α : Type u_1
ι : Sort ?u.12832
κ : ι → Sort ?u.12837
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
u : β → α
l : LowerAdjoint u
l₁ : α → β
gc'✝¹ : GaloisConnection l₁ u
l₂ : α → β
gc'✝ : GaloisConnection l₂ u
h : { toFun := l₁, gc' := gc'✝¹ }.toFun = { toFun := l₂, gc' := gc'✝ }.toFun
⊢ { toFun := l₁, gc' := gc'✝¹ } = { toFun := l₂, gc' := gc'✝ }
Theorem: CategoryTheory.Limits.parallelPair_functor_obj
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: cases j <;> rfl
state_before: C : Type u
inst✝ : Category C
X Y : C
F : WalkingParallelPair ⥤ C
j : WalkingParallelPair
⊢ (parallelPair (F.map left) (F.map right)).obj j = F.obj j
Theorem: SymAlg.unsym_mul_self
File: Mathlib/Algebra/Symmetrized.lean

tactic: rw [mul_def, unsym_sym, ← two_mul, invOf_mul_self_assoc]
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : Invertible 2
a : αˢʸᵐ
⊢ ↑unsym (a * a) = ↑unsym a * ↑unsym a
Theorem: IsUnifLocDoublingMeasure.eventually_measure_le_scaling_constant_mul'
File: Mathlib/MeasureTheory/Measure/Doubling.lean

tactic: convert eventually_nhdsWithin_pos_mul_left hK (eventually_measure_le_scaling_constant_mul μ K⁻¹)
state_before: α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
hK : 0 < K
⊢ ∀ᶠ (r : ℝ) in 𝓝[Ioi 0] 0, ∀ (x : α), ↑↑μ (closedBall x r) ≤ ↑(scalingConstantOf μ K⁻¹) * ↑↑μ (closedBall x (K * r))

tactic: simp [inv_mul_cancel_left₀ hK.ne']
state_before: case h.e'_2.h.h.h.e'_3.h.e'_3.h.e'_4
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
hK : 0 < K
x✝ : ℝ
a✝ : α
⊢ x✝ = K⁻¹ * (K * x✝)
Theorem: Finset.cons_induction
File: Mathlib/Data/Finset/Basic.lean

tactic: exact empty
state_before: case empty
α✝ : Type ?u.115585
β : Type ?u.115588
γ : Type ?u.115591
inst✝ : DecidableEq α✝
s t u v : Finset α✝
a b : α✝
α : Type u_1
p : Finset α → Prop
empty : p ∅
cons : ∀ ⦃a : α⦄ {s : Finset α} (h : ¬a ∈ s), p s → p (Finset.cons a s h)
nd : Nodup 0
⊢ p { val := 0, nodup := nd }

tactic: cases' nodup_cons.1 nd with m nd'
state_before: case cons
α✝ : Type ?u.115585
β : Type ?u.115588
γ : Type ?u.115591
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : Finset α → Prop
empty : p ∅
cons : ∀ ⦃a : α⦄ {s : Finset α} (h : ¬a ∈ s), p s → p (Finset.cons a s h)
a : α
s : Multiset α
IH : ∀ (nd : Nodup s), p { val := s, nodup := nd }
nd : Nodup (a ::ₘ s)
⊢ p { val := a ::ₘ s, nodup := nd }

tactic: rw [← (eq_of_veq _ : Finset.cons a ⟨s, _⟩ m = ⟨a ::ₘ s, nd⟩)]
state_before: case cons.intro
α✝ : Type ?u.115585
β : Type ?u.115588
γ : Type ?u.115591
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : Finset α → Prop
empty : p ∅
cons : ∀ ⦃a : α⦄ {s : Finset α} (h : ¬a ∈ s), p s → p (Finset.cons a s h)
a : α
s : Multiset α
IH : ∀ (nd : Nodup s), p { val := s, nodup := nd }
nd : Nodup (a ::ₘ s)
m : ¬a ∈ s
nd' : Nodup s
⊢ p { val := a ::ₘ s, nodup := nd }

tactic: exact cons m (IH nd')
state_before: case cons.intro
α✝ : Type ?u.115585
β : Type ?u.115588
γ : Type ?u.115591
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : Finset α → Prop
empty : p ∅
cons : ∀ ⦃a : α⦄ {s : Finset α} (h : ¬a ∈ s), p s → p (Finset.cons a s h)
a : α
s : Multiset α
IH : ∀ (nd : Nodup s), p { val := s, nodup := nd }
nd : Nodup (a ::ₘ s)
m : ¬a ∈ s
nd' : Nodup s
⊢ p (Finset.cons a { val := s, nodup := ?m.115914 } m)

tactic: rw [cons_val]
state_before: α✝ : Type ?u.115585
β : Type ?u.115588
γ : Type ?u.115591
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : Finset α → Prop
empty : p ∅
cons : ∀ ⦃a : α⦄ {s : Finset α} (h : ¬a ∈ s), p s → p (Finset.cons a s h)
a : α
s : Multiset α
IH : ∀ (nd : Nodup s), p { val := s, nodup := nd }
nd : Nodup (a ::ₘ s)
m : ¬a ∈ s
nd' : Nodup s
⊢ (Finset.cons a { val := s, nodup := nd' } m).val = { val := a ::ₘ s, nodup := nd }.val
Theorem: Finset.sigmaLift_mono
File: Mathlib/Data/Finset/Sigma.lean

tactic: rintro x hx
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a✝ : (i : ι) × α i
b✝ : (i : ι) × β i
h : ∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b
a : (i : ι) × α i
b : (i : ι) × β i
⊢ sigmaLift f a b ⊆ sigmaLift g a b

tactic: rw [mem_sigmaLift] at hx⊢
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a✝ : (i : ι) × α i
b✝ : (i : ι) × β i
h : ∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b
a : (i : ι) × α i
b : (i : ι) × β i
x : (i : ι) × γ i
hx : x ∈ sigmaLift f a b
⊢ x ∈ sigmaLift g a b

tactic: obtain ⟨ha, hb, hx⟩ := hx
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a✝ : (i : ι) × α i
b✝ : (i : ι) × β i
h : ∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b
a : (i : ι) × α i
b : (i : ι) × β i
x : (i : ι) × γ i
hx : ∃ ha hb, x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
⊢ ∃ ha hb, x.snd ∈ g (ha ▸ a.snd) (hb ▸ b.snd)

tactic: exact ⟨ha, hb, h hx⟩
state_before: case intro.intro
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a✝ : (i : ι) × α i
b✝ : (i : ι) × β i
h : ∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b
a : (i : ι) × α i
b : (i : ι) × β i
x : (i : ι) × γ i
ha : a.fst = x.fst
hb : b.fst = x.fst
hx : x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
⊢ ∃ ha hb, x.snd ∈ g (ha ▸ a.snd) (hb ▸ b.snd)
Theorem: Finset.Icc_eq_cons_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: classical rw [cons_eq_insert, Ioc_insert_left h]
state_before: ι : Type ?u.108081
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a ≤ b
⊢ Icc a b = cons a (Ioc a b) (_ : ¬a ∈ Ioc a b)

tactic: rw [cons_eq_insert, Ioc_insert_left h]
state_before: ι : Type ?u.108081
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a ≤ b
⊢ Icc a b = cons a (Ioc a b) (_ : ¬a ∈ Ioc a b)
Theorem: SimplicialObject.Split.ιSummand_naturality_symm
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: erw [S₁.s.ιSummand_eq, S₂.s.ιSummand_eq, assoc, Φ.F.naturality, ← Φ.comm_assoc ]
state_before: C : Type u_1
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
S₁ S₂ : Split C
Φ : S₁ ⟶ S₂
Δ : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
⊢ Splitting.ιSummand S₁.s A ≫ Φ.F.app Δ = Hom.f Φ (len A.fst.unop) ≫ Splitting.ιSummand S₂.s A
Theorem: hasSum_sum
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp only [hasSum_zero, sum_empty, forall_true_iff]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.244028
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
f : γ → β → α
a : γ → α
s : Finset γ
⊢ (∀ (i : γ), i ∈ ∅ → HasSum (f i) (a i)) → HasSum (fun b => ∑ i in ∅, f i b) (∑ i in ∅, a i)

tactic: simp (config := { contextual := true }) only [mem_insert, forall_eq_or_imp, not_false_iff,
  sum_insert, and_imp]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.244028
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
f : γ → β → α
a : γ → α
s : Finset γ
⊢ ∀ ⦃a_1 : γ⦄ {s : Finset γ},
    ¬a_1 ∈ s →
      ((∀ (i : γ), i ∈ s → HasSum (f i) (a i)) → HasSum (fun b => ∑ i in s, f i b) (∑ i in s, a i)) →
        (∀ (i : γ), i ∈ insert a_1 s → HasSum (f i) (a i)) →
          HasSum (fun b => ∑ i in insert a_1 s, f i b) (∑ i in insert a_1 s, a i)

tactic: exact fun x s _ IH hx h ↦ hx.add (IH h)
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.244028
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
f : γ → β → α
a : γ → α
s : Finset γ
⊢ ∀ ⦃a_1 : γ⦄ {s : Finset γ},
    ¬a_1 ∈ s →
      ((∀ (i : γ), i ∈ s → HasSum (f i) (a i)) → HasSum (fun b => ∑ i in s, f i b) (∑ i in s, a i)) →
        HasSum (f a_1) (a a_1) →
          (∀ (a_5 : γ), a_5 ∈ s → HasSum (f a_5) (a a_5)) →
            HasSum (fun b => f a_1 b + ∑ i in s, f i b) (a a_1 + ∑ i in s, a i)
Theorem: isOpenMap_inl
File: Mathlib/Topology/Constructions.lean

tactic: simpa [isOpen_sum_iff, preimage_image_eq u Sum.inl_injective]
state_before: α : Type u
β : Type v
γ : Type ?u.119697
δ : Type ?u.119700
ε : Type ?u.119703
ζ : Type ?u.119706
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
u : Set α
hu : IsOpen u
⊢ IsOpen (inl '' u)
Theorem: tendsto_comp_coe_Ioo_atTop
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← map_coe_Ioo_atTop h, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f (𝓝[Iio b] b) l

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
Theorem: Polynomial.mem_iff_annIdealGenerator_dvd
File: Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean

tactic: rw [← Ideal.mem_span_singleton, span_singleton_annIdealGenerator]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
p : 𝕜[X]
a : A
⊢ p ∈ annIdeal 𝕜 a ↔ annIdealGenerator 𝕜 a ∣ p
Theorem: mem_openSegment_translate
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp_rw [← vadd_eq_add, ← vadd_openSegment, vadd_mem_vadd_set_iff]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.133397
G : Type ?u.133400
ι : Type ?u.133403
π : ι → Type ?u.133408
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
a x b c : E
⊢ a + x ∈ openSegment 𝕜 (a + b) (a + c) ↔ x ∈ openSegment 𝕜 b c
Theorem: MonotoneOn.image_upperBounds_subset_upperBounds_image
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, ha, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
Hf : MonotoneOn f t
a : α
Hst✝ Hst : s ⊆ t
⊢ f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)

tactic: exact Hf.mem_upperBounds_image Hst ha.1 ha.2
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
Hf : MonotoneOn f t
a✝ : α
Hst✝ Hst : s ⊆ t
a : α
ha : a ∈ upperBounds s ∩ t
⊢ f a ∈ upperBounds (f '' s)
Theorem: List.TProd.mk_elim
File: Mathlib/Data/Prod/TProd.lean

tactic: simp [elim_mk]
state_before: ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
v : TProd α l
i : ι
hi : i ∈ l
⊢ TProd.elim (TProd.mk l (TProd.elim' h v)) hi = TProd.elim v hi
Theorem: MvPolynomial.eval₂_mul_C
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ (eval₂ f g p * ↑f a * Finsupp.prod 0 fun n e => g n ^ e) = eval₂ f g p * ↑f a
Theorem: Computation.liftRel_of_mem
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [mem_unique ma' ma]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a' b

tactic: exact ⟨b, mb, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a b

tactic: rw [mem_unique mb' mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b'

tactic: exact ⟨a, ma, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b
Theorem: SimpleGraph.edgeSet_inf
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext ⟨x, y⟩
state_before: ι : Sort ?u.70630
𝕜 : Type ?u.70633
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
G₁ G₂ : SimpleGraph V
⊢ edgeSet (G₁ ⊓ G₂) = edgeSet G₁ ∩ edgeSet G₂

tactic: rfl
state_before: case h.mk.mk
ι : Sort ?u.70630
𝕜 : Type ?u.70633
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
G₁ G₂ : SimpleGraph V
x✝ : Sym2 V
x y : V
⊢ Quot.mk Setoid.r (x, y) ∈ edgeSet (G₁ ⊓ G₂) ↔ Quot.mk Setoid.r (x, y) ∈ edgeSet G₁ ∩ edgeSet G₂
Theorem: BoxIntegral.BoxAdditiveMap.map_split_add
File: Mathlib/Analysis/BoxIntegral/Partition/Additive.lean

tactic: rw [← f.sum_partition_boxes hI (isPartitionSplit I i x), sum_split_boxes]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
N : Type ?u.40368
inst✝¹ : AddCommMonoid M
inst✝ : AddCommMonoid N
I₀ : WithTop (Box ι)
I J : Box ι
i✝ : ι
f : ι →ᵇᵃ[I₀] M
hI : ↑I ≤ I₀
i : ι
x : ℝ
⊢ Option.elim' 0 (↑f) (splitLower I i x) + Option.elim' 0 (↑f) (splitUpper I i x) = ↑f I
Theorem: NNReal.coe_iInf
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [iInf, iInf, coe_sInf, ← Set.range_comp]
state_before: ι : Sort u_1
s : ι → ℝ≥0
⊢ ↑(⨅ (i : ι), s i) = ⨅ (i : ι), ↑(s i)

tactic: rfl
state_before: ι : Sort u_1
s : ι → ℝ≥0
⊢ sInf (Set.range (toReal ∘ fun i => s i)) = sInf (Set.range fun i => ↑(s i))
Theorem: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_toSignedMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.716310
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hs : restrict 0 Set.univ ≤ restrict s Set.univ
⊢ Measure.toSignedMeasure (toMeasureOfZeroLE s Set.univ (_ : MeasurableSet Set.univ) hs) = s

tactic: intro hi
state_before: case h
α : Type u_1
β : Type ?u.716310
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : restrict 0 Set.univ ≤ restrict s Set.univ
i : Set α
⊢ MeasurableSet i → ↑(Measure.toSignedMeasure (toMeasureOfZeroLE s Set.univ (_ : MeasurableSet Set.univ) hs)) i = ↑s i

tactic: simp [hi, toMeasureOfZeroLE_apply _ _ _ hi]
state_before: case h
α : Type u_1
β : Type ?u.716310
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : restrict 0 Set.univ ≤ restrict s Set.univ
i : Set α
hi : MeasurableSet i
⊢ ↑(Measure.toSignedMeasure (toMeasureOfZeroLE s Set.univ (_ : MeasurableSet Set.univ) hs)) i = ↑s i
Theorem: List.Chain'.two_mul_count_bool_le_length_add_one
File: Mathlib/Data/Bool/Count.lean

tactic: rw [hl.two_mul_count_bool_eq_ite]
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ 2 * count b l ≤ length l + 1

tactic: split_ifs <;> simp [Nat.le_succ_of_le]
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ (if Even (length l) then length l else if (some b == head? l) = true then length l + 1 else length l - 1) ≤
    length l + 1
Theorem: ModelWithCorners.unique_diff_preimage
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [inter_comm]
state_before: 𝕜 : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_1
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
s : Set H
hs : IsOpen s
⊢ UniqueDiffOn 𝕜 (↑(ModelWithCorners.symm I) ⁻¹' s ∩ range ↑I)

tactic: exact I.unique_diff.inter (hs.preimage I.continuous_invFun)
state_before: 𝕜 : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_1
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
s : Set H
hs : IsOpen s
⊢ UniqueDiffOn 𝕜 (range ↑I ∩ ↑(ModelWithCorners.symm I) ⁻¹' s)
Theorem: Equiv.Perm.subtypeCongr.apply
File: Mathlib/Logic/Equiv/Basic.lean

tactic: by_cases h : p a <;> simp [Perm.subtypeCongr, h]
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
a : ε
⊢ ↑(subtypeCongr ep en) a = if h : p a then ↑(↑ep { val := a, property := h }) else ↑(↑en { val := a, property := h })
Theorem: Real.arcsin_of_one_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [← arcsin_projIcc, projIcc_of_right_le _ hx, Subtype.coe_mk, arcsin_one]
state_before: x : ℝ
hx : 1 ≤ x
⊢ arcsin x = π / 2
Theorem: CategoryTheory.MorphismProperty.RespectsIso.of_respects_arrow_iso
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
⊢ RespectsIso P

tactic: intro X Y Z e f hf
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
⊢ ∀ {X Y Z : C} (e : X ≅ Y) (f : Y ⟶ Z), P f → P (e.hom ≫ f)

tactic: refine' hP (Arrow.mk f) (Arrow.mk (e.hom ≫ f)) (Arrow.isoMk e.symm (Iso.refl _) _) hf
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
hf : P f
⊢ P (e.hom ≫ f)

tactic: dsimp
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
hf : P f
⊢ e.symm.hom ≫ (Arrow.mk (e.hom ≫ f)).hom = (Arrow.mk f).hom ≫ (Iso.refl (Arrow.mk f).right).hom

tactic: simp only [Iso.inv_hom_id_assoc, Category.comp_id]
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
hf : P f
⊢ e.inv ≫ e.hom ≫ f = f ≫ 𝟙 Z

tactic: intro X Y Z e f hf
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y), P f → P (f ≫ e.hom)

tactic: refine' hP (Arrow.mk f) (Arrow.mk (f ≫ e.hom)) (Arrow.isoMk (Iso.refl _) e _) hf
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : P f
⊢ P (f ≫ e.hom)

tactic: dsimp
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : P f
⊢ (Iso.refl (Arrow.mk f).left).hom ≫ (Arrow.mk (f ≫ e.hom)).hom = (Arrow.mk f).hom ≫ e.hom

tactic: simp only [Category.id_comp]
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.17335
inst✝ : Category D
P : MorphismProperty C
hP : ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : P f
⊢ 𝟙 X ≫ f ≫ e.hom = f ≫ e.hom
Theorem: ZNum.dvd_iff_mod_eq_zero
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← dvd_to_int, Int.dvd_iff_emod_eq_zero, ← to_int_inj, mod_to_int]
state_before: m n : ZNum
⊢ m ∣ n ↔ n % m = 0

tactic: rfl
state_before: m n : ZNum
⊢ ↑n % ↑m = 0 ↔ ↑n % ↑m = ↑0
Theorem: List.Duplicate.of_duplicate_cons
File: Mathlib/Data/List/Duplicate.lean

tactic: simpa [duplicate_cons_iff, hx.symm] using h
state_before: α : Type u_1
l : List α
x y : α
h : x ∈+ y :: l
hx : x ≠ y
⊢ x ∈+ l
Theorem: iterate_frobenius
File: Mathlib/Algebra/CharP/Basic.lean

tactic: induction n with
| zero => simp
| succ n n_ih =>
    rw [Function.iterate_succ', pow_succ', pow_mul, Function.comp_apply, frobenius_def, n_ih]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
S : Type v
inst✝³ : CommSemiring S
f : R →* S
g : R →+* S
p : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : CharP R p
inst✝ : CharP S p
x y : R
n : ℕ
⊢ (↑(frobenius R p)^[n]) x = x ^ p ^ n

tactic: simp
state_before: case zero
R : Type u_1
inst✝⁴ : CommSemiring R
S : Type v
inst✝³ : CommSemiring S
f : R →* S
g : R →+* S
p : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : CharP R p
inst✝ : CharP S p
x y : R
⊢ (↑(frobenius R p)^[Nat.zero]) x = x ^ p ^ Nat.zero

tactic: rw [Function.iterate_succ', pow_succ', pow_mul, Function.comp_apply, frobenius_def, n_ih]
state_before: case succ
R : Type u_1
inst✝⁴ : CommSemiring R
S : Type v
inst✝³ : CommSemiring S
f : R →* S
g : R →+* S
p : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : CharP R p
inst✝ : CharP S p
x y : R
n : ℕ
n_ih : (↑(frobenius R p)^[n]) x = x ^ p ^ n
⊢ (↑(frobenius R p)^[Nat.succ n]) x = x ^ p ^ Nat.succ n
Theorem: Polynomial.zero_le_degree_iff
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← not_lt, Nat.WithBot.lt_zero_iff, degree_eq_bot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.700995
⊢ 0 ≤ degree p ↔ p ≠ 0
Theorem: Int.mul_neg_of_pos_of_neg
File: Std/Data/Int/Lemmas.lean

tactic: have h : a * b < a * 0 := Int.mul_lt_mul_of_pos_left hb ha
state_before: a b : Int
ha : 0 < a
hb : b < 0
⊢ a * b < 0

tactic: rwa [Int.mul_zero] at h
state_before: a b : Int
ha : 0 < a
hb : b < 0
h : a * b < a * 0
⊢ a * b < 0
Theorem: AlternatingMap.zero_compLinearMap
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_3
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_4
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type ?u.360842
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type ?u.360872
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type ?u.361260
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_5
ι' : Type ?u.361651
ι'' : Type ?u.361654
M₂ : Type u_2
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
M₃ : Type ?u.361687
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
g : M₂ →ₗ[R] M
⊢ compLinearMap 0 g = 0

tactic: simp only [compLinearMap_apply, zero_apply]
state_before: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_3
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_4
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type ?u.360842
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type ?u.360872
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type ?u.361260
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_5
ι' : Type ?u.361651
ι'' : Type ?u.361654
M₂ : Type u_2
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
M₃ : Type ?u.361687
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
g : M₂ →ₗ[R] M
x✝ : ι → M₂
⊢ ↑(compLinearMap 0 g) x✝ = ↑0 x✝