tasksource/leandojo huggingface dataset:
Theorem: AffineSubspace.isPreconnected_setOf_wOppSide
File: Mathlib/Analysis/Convex/Side.lean

tactic: rcases Set.eq_empty_or_nonempty (s : Set P) with (h | h)
state_before: R : Type ?u.501598
V : Type u_1
V' : Type ?u.501604
P : Type u_2
P' : Type ?u.501610
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
⊢ IsPreconnected {y | WOppSide s x y}

tactic: rw [coe_eq_bot_iff] at h
state_before: case inl
R : Type ?u.501598
V : Type u_1
V' : Type ?u.501604
P : Type u_2
P' : Type ?u.501610
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : ↑s = ∅
⊢ IsPreconnected {y | WOppSide s x y}

tactic: simp only [h, not_wOppSide_bot]
state_before: case inl
R : Type ?u.501598
V : Type u_1
V' : Type ?u.501604
P : Type u_2
P' : Type ?u.501610
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : s = ⊥
⊢ IsPreconnected {y | WOppSide s x y}

tactic: exact isPreconnected_empty
state_before: case inl
R : Type ?u.501598
V : Type u_1
V' : Type ?u.501604
P : Type u_2
P' : Type ?u.501610
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : s = ⊥
⊢ IsPreconnected {y | False}

tactic: exact (isConnected_setOf_wOppSide x h).isPreconnected
state_before: case inr
R : Type ?u.501598
V : Type u_1
V' : Type ?u.501604
P : Type u_2
P' : Type ?u.501610
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : Set.Nonempty ↑s
⊢ IsPreconnected {y | WOppSide s x y}
Theorem: BilinForm.dualBasis_repr_apply
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [dualBasis, Basis.map_repr, LinearEquiv.symm_symm, LinearEquiv.trans_apply,
  Basis.dualBasis_repr, toDual_def]
state_before: R : Type ?u.1740676
M : Type ?u.1740679
inst✝¹⁹ : Semiring R
inst✝¹⁸ : AddCommMonoid M
inst✝¹⁷ : Module R M
R₁ : Type ?u.1740715
M₁ : Type ?u.1740718
inst✝¹⁶ : Ring R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type ?u.1741327
M₂ : Type ?u.1741330
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type ?u.1741517
M₃ : Type ?u.1741520
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type u_2
K : Type u_1
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1743325
inst✝⁴ : AddCommMonoid M₂'
inst✝³ : Module R₂ M₂'
inst✝² : FiniteDimensional K V
ι : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : BilinForm K V
hB : Nondegenerate B
b : Basis ι K V
x : V
i : ι
⊢ ↑(↑(dualBasis B hB b).repr x) i = bilin B x (↑b i)
Theorem: associated_of_factorization_eq
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp_rw [factorization, AddEquiv.apply_eq_iff_eq] at h
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
h : factorization a = factorization b
⊢ a ~ᵤ b

tactic: rwa [associated_iff_normalizedFactors_eq_normalizedFactors ha hb]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
h : normalizedFactors a = normalizedFactors b
⊢ a ~ᵤ b
Theorem: Finset.prod_const_one
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp only [Finset.prod, Multiset.map_const', Multiset.prod_replicate, one_pow]
state_before: ι : Type ?u.271647
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
⊢ ∏ _x in s, 1 = 1
Theorem: Real.rpow_logb_of_neg
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [rpow_logb_eq_abs b_pos b_ne_one (ne_of_lt hx)]
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x < 0
⊢ b ^ logb b x = -x

tactic: exact abs_of_neg hx
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x < 0
⊢ abs x = -x
Theorem: Order.Icc_succ_left_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [← Ici_inter_Iic, Ici_succ_of_not_isMax ha, Ioi_inter_Iic]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
⊢ Icc (succ a) b = Ioc a b
Theorem: EuclideanGeometry.angle_eq_arctan_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)

tactic: rw [ne_comm, ← @vsub_ne_zero V] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub' V p₃ p₂, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, angle_add_eq_arctan_of_inner_eq_zero h h0]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
Theorem: CategoryTheory.Functor.IsLocalization.of_iso
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: have h := Localization.inverts L₁ W
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type ?u.76257
inst✝¹ : Category E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
⊢ IsLocalization L₂ W

tactic: rw [MorphismProperty.IsInvertedBy.iff_of_iso W e] at h
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type ?u.76257
inst✝¹ : Category E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₁
⊢ IsLocalization L₂ W

tactic: let F₁ := Localization.Construction.lift L₁ (Localization.inverts L₁ W)
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type ?u.76257
inst✝¹ : Category E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
⊢ IsLocalization L₂ W

tactic: let F₂ := Localization.Construction.lift L₂ h
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type ?u.76257
inst✝¹ : Category E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
F₁ : MorphismProperty.Localization W ⥤ D := Construction.lift L₁ (_ : MorphismProperty.IsInvertedBy W L₁)
⊢ IsLocalization L₂ W

tactic: exact
  { inverts := h
    nonempty_isEquivalence :=
      Nonempty.intro (IsEquivalence.ofIso (liftNatIso W.Q W L₁ L₂ F₁ F₂ e) inferInstance) }
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type ?u.76257
inst✝¹ : Category E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
F₁ : MorphismProperty.Localization W ⥤ D := Construction.lift L₁ (_ : MorphismProperty.IsInvertedBy W L₁)
F₂ : MorphismProperty.Localization W ⥤ D := Construction.lift L₂ h
⊢ IsLocalization L₂ W
Theorem: PadicInt.lift_spec
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: ext r
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
n : ℕ
⊢ RingHom.comp (toZModPow n) (lift f_compat) = f n

tactic: rw [RingHom.comp_apply, ← ZMod.nat_cast_zmod_val (f n r), ← map_natCast <| toZModPow n, ←
  sub_eq_zero, ← RingHom.map_sub, ← RingHom.mem_ker, ker_toZModPow]
state_before: case a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
n : ℕ
r : R
⊢ ↑(RingHom.comp (toZModPow n) (lift f_compat)) r = ↑(f n) r

tactic: apply lift_sub_val_mem_span
state_before: case a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
n : ℕ
r : R
⊢ ↑(lift f_compat) r - ↑(ZMod.val (↑(f n) r)) ∈ Ideal.span {↑p ^ n}
Theorem: Ordinal.cof_eq_zero
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp [e]
state_before: α : Type ?u.42348
r : α → α → Prop
o : Ordinal
e : o = 0
⊢ cof o = 0
Theorem: YoungDiagram.le_of_transpose_le
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp only [mem_cells, mem_transpose]
state_before: μ ν : YoungDiagram
h_le : transpose μ ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ c ∈ (transpose ν).cells

tactic: apply h_le
state_before: μ ν : YoungDiagram
h_le : transpose μ ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ Prod.swap c ∈ ν

tactic: simpa
state_before: case a
μ ν : YoungDiagram
h_le : transpose μ ≤ ν
c : ℕ × ℕ
hc : c ∈ μ.cells
⊢ Prod.swap c ∈ (transpose μ).cells
Theorem: Basis.det_comp
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: rw [Basis.det_apply, Basis.det_apply, ← f.det_toMatrix e, ← Matrix.det_mul,
  e.toMatrix_eq_toMatrix_constr (f ∘ v), e.toMatrix_eq_toMatrix_constr v, ← toMatrix_comp,
  e.constr_comp]
state_before: R : Type ?u.2622120
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2622711
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type u_2
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι A M
f : M →ₗ[A] M
v : ι → M
⊢ ↑(det e) (↑f ∘ v) = ↑LinearMap.det f * ↑(det e) v
Theorem: Set.pairwise_disjoint_Ioc_int_cast
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [zero_add] using pairwise_disjoint_Ioc_add_int_cast (0 : α)
state_before: α : Type u_1
inst✝ : OrderedRing α
a : α
⊢ Pairwise (Disjoint on fun n => Ioc (↑n) (↑n + 1))
Theorem: Nat.Primrec'.mul
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec 0
      (fun y IH =>
        Vector.head (Vector.tail (Vector.tail (y ::ᵥ IH ::ᵥ Vector.tail v))) +
          Vector.head (Vector.tail (y ::ᵥ IH ::ᵥ Vector.tail v)))
      (Vector.head v) =
    Vector.head v * Vector.head (Vector.tail v)

tactic: induction v.head <;> simp [*, Nat.succ_mul]
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec 0 (fun y IH => Vector.head (Vector.tail v) + IH) (Vector.head v) = Vector.head v * Vector.head (Vector.tail v)

tactic: rw [add_comm]
state_before: case succ
v : Vector ℕ (Nat.succ 0 + 1)
n✝ : ℕ
n_ih✝ : Nat.rec 0 (fun y IH => Vector.head (Vector.tail v) + IH) n✝ = n✝ * Vector.head (Vector.tail v)
⊢ Vector.head (Vector.tail v) + n✝ * Vector.head (Vector.tail v) =
    n✝ * Vector.head (Vector.tail v) + Vector.head (Vector.tail v)
Theorem: Set.le_einfsep_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [einfsep, le_iInf_iff]
state_before: α : Type u_1
β : Type ?u.385
inst✝ : EDist α
x y : α
s t : Set α
d : ℝ≥0∞
⊢ d ≤ einfsep s ↔ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → d ≤ edist x y
Theorem: ContinuousLinearMap.isOpenMap_of_ne_zero
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: continuity
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : ↑f x ≠ 0
y : M
⊢ Continuous fun a => y + (a - ↑f y) • (↑f x)⁻¹ • x

tactic: simp
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : ↑f x ≠ 0
y : M
⊢ (fun a => y + (a - ↑f y) • (↑f x)⁻¹ • x) (↑f y) = y

tactic: simp [hx]
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : ↑f x ≠ 0
y : M
a : R
⊢ ↑f ((fun a => y + (a - ↑f y) • (↑f x)⁻¹ • x) a) = a
Theorem: MeasureTheory.MeasurePreserving.restrict_preimage_emb
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rw [← hf.map_eq, h₂.restrict_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.52769
δ : Type ?u.52772
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f
h₂ : MeasurableEmbedding f
s : Set β
⊢ map f (restrict μa (f ⁻¹' s)) = restrict μb s
Theorem: TypeVec.subtypeVal_toSubtype
File: Mathlib/Data/TypeVec.lean

tactic: ext (i x)
state_before: n : ℕ
α : TypeVec n
p : α ⟹ repeat n Prop
⊢ subtypeVal p ⊚ toSubtype p = fun x => Subtype.val

tactic: induction i <;> dsimp only [toSubtype, comp, subtypeVal] at *
state_before: case a.h
n : ℕ
α : TypeVec n
p : α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (p i x) }) i
⊢ (subtypeVal p ⊚ toSubtype p) i x = ↑x

tactic: simp [*]
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec n✝} (p : α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (p a✝ x) }), subtypeVal p a✝ (toSubtype p a✝ x) = ↑x
α : TypeVec (Nat.succ n✝)
p : α ⟹ repeat (Nat.succ n✝) Prop
x : { x // ofRepeat (p (Fin2.fs a✝) x) }
⊢ subtypeVal (dropFun p) a✝ (toSubtype (dropFun p) a✝ x) = ↑x
Theorem: Turing.PartrecToTM2.trList_ne_consₗ
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [trList] at h
state_before: a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trList (a :: l)
⊢ x ≠ Γ'.consₗ

tactic: obtain h | rfl | h := h
state_before: a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trNat a ∨ x = Γ'.cons ∨ x ∈ trList l
⊢ x ≠ Γ'.consₗ

tactic: rintro rfl
state_before: case inl
a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trNat a
⊢ x ≠ Γ'.consₗ

tactic: cases trNat_natEnd _ _ h
state_before: case inl
a : ℕ
l : List ℕ
h : Γ'.consₗ ∈ trNat a
⊢ False

tactic: rintro ⟨⟩
state_before: case inr.inl
a : ℕ
l : List ℕ
⊢ Γ'.cons ≠ Γ'.consₗ

tactic: exact trList_ne_consₗ l _ h
state_before: case inr.inr
a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trList l
⊢ x ≠ Γ'.consₗ
Theorem: aemeasurable_const_smul_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
state_before: M : Type ?u.3506644
β : Type u_2
α : Type u_1
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : MeasureTheory.Measure α
G : Type u_3
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : AEMeasurable fun x => c • f x
⊢ AEMeasurable f
Theorem: OneHom.cancel_left
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [← OneHom.comp_apply, h, OneHom.comp_apply]
state_before: α : Type ?u.167782
β : Type ?u.167785
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.167797
H : Type ?u.167800
F : Type ?u.167803
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
g : OneHom N P
f₁ f₂ : OneHom M N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
Theorem: toIcoMod_add_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoMod_add_right]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (p + b) = toIcoMod hp a b
Theorem: dNext_nat
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [dNext]
state_before: ι : Type ?u.103173
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : ChainComplex V ℕ
i : ℕ
f : (i j : ℕ) → X C i ⟶ X D j
⊢ ↑(dNext i) f = d C i (i - 1) ≫ f (i - 1) i

tactic: cases i
state_before: ι : Type ?u.103173
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : ChainComplex V ℕ
i : ℕ
f : (i j : ℕ) → X C i ⟶ X D j
⊢ d C i (ComplexShape.next (ComplexShape.down ℕ) i) ≫ f (ComplexShape.next (ComplexShape.down ℕ) i) i =
    d C i (i - 1) ≫ f (i - 1) i

tactic: simp only [shape, ChainComplex.next_nat_zero, ComplexShape.down_Rel, Nat.one_ne_zero,
  not_false_iff, zero_comp]
state_before: case zero
ι : Type ?u.103173
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → X C i ⟶ X D j
⊢ d C Nat.zero (ComplexShape.next (ComplexShape.down ℕ) Nat.zero) ≫
      f (ComplexShape.next (ComplexShape.down ℕ) Nat.zero) Nat.zero =
    d C Nat.zero (Nat.zero - 1) ≫ f (Nat.zero - 1) Nat.zero

tactic: congr <;> simp
state_before: case succ
ι : Type ?u.103173
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → X C i ⟶ X D j
n✝ : ℕ
⊢ d C (Nat.succ n✝) (ComplexShape.next (ComplexShape.down ℕ) (Nat.succ n✝)) ≫
      f (ComplexShape.next (ComplexShape.down ℕ) (Nat.succ n✝)) (Nat.succ n✝) =
    d C (Nat.succ n✝) (Nat.succ n✝ - 1) ≫ f (Nat.succ n✝ - 1) (Nat.succ n✝)
Theorem: multiplicity.multiplicity_self
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← Nat.cast_one]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ multiplicity a a = 1

tactic: exact eq_coe_iff.2 ⟨by simp, fun ⟨b, hb⟩ => ha (isUnit_iff_dvd_one.2
          ⟨b, mul_left_cancel₀ ha0 <| by simpa [_root_.pow_succ, mul_assoc] using hb⟩)⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ multiplicity a a = ↑1

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ a ^ 1 ∣ a

tactic: simpa [_root_.pow_succ, mul_assoc] using hb
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : a = a ^ (1 + 1) * b
⊢ a * 1 = a * (a * b)
Theorem: CategoryTheory.LaxMonoidalFunctor.right_unitality_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: rw [Iso.inv_comp_eq, F.right_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp,
  Iso.hom_inv_id, F.toFunctor.map_id, comp_id]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (ρ_ (F.obj X)).inv ≫ (𝟙 (F.obj X) ⊗ F.ε) ≫ μ F X (𝟙_ C) = F.map (ρ_ X).inv
Theorem: OpenEmbedding.open_iff_preimage_open
File: Mathlib/Topology/Maps.lean

tactic: rw [hf.open_iff_image_open, image_preimage_eq_inter_range, inter_eq_self_of_subset_left hs]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.239202
δ : Type ?u.239205
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : OpenEmbedding f
s : Set β
hs : s ⊆ range f
⊢ IsOpen s ↔ IsOpen (f ⁻¹' s)
Theorem: Filter.mem_lift_sets
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [id, exists_mem_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.8191
ι : Sort ?u.8194
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
hg : Monotone g
s : Set β
⊢ (∃ i, i ∈ f ∧ ∃ x, x ∈ g i ∧ id x ⊆ s) ↔ ∃ t, t ∈ f ∧ s ∈ g t
Theorem: indicator_le_thickenedIndicator
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: intro a
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
⊢ (indicator E fun x => 1) ≤ ↑(thickenedIndicator δ_pos E)

tactic: by_cases a ∈ E
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
a : α
⊢ indicator E (fun x => 1) a ≤ ↑(thickenedIndicator δ_pos E) a

tactic: simp only [h, indicator_of_mem, thickenedIndicator_one δ_pos E h, le_refl]
state_before: case pos
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
a : α
h : a ∈ E
⊢ indicator E (fun x => 1) a ≤ ↑(thickenedIndicator δ_pos E) a

tactic: simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
state_before: case neg
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
a : α
h : ¬a ∈ E
⊢ indicator E (fun x => 1) a ≤ ↑(thickenedIndicator δ_pos E) a
Theorem: Complex.ringHom_eq_id_or_conj_of_continuous
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa only [FunLike.ext_iff] using real_algHom_eq_id_or_conj (AlgHom.mk' f (map_real_smul f hf))
state_before: E : Type ?u.690001
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ →+* ℂ
hf : Continuous ↑f
⊢ f = RingHom.id ℂ ∨ f = starRingEnd ℂ
Theorem: Finset.inl_mem_sumLift₂
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [mem_sumLift₂, or_iff_left]
state_before: α₁ : Type u_3
α₂ : Type u_4
β₁ : Type u_5
β₂ : Type u_6
γ₁ : Type u_2
γ₂ : Type u_1
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ inl c₁ ∈ sumLift₂ f g a b ↔ ∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f a₁ b₁

tactic: simp only [inl.injEq, exists_and_left, exists_eq_left']
state_before: α₁ : Type u_3
α₂ : Type u_4
β₁ : Type u_5
β₂ : Type u_6
γ₁ : Type u_2
γ₂ : Type u_1
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ (∃ a₁ b₁ c₁_1, a = inl a₁ ∧ b = inl b₁ ∧ inl c₁ = inl c₁_1 ∧ c₁_1 ∈ f a₁ b₁) ↔
    ∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f a₁ b₁

α₁ : Type u_3
α₂ : Type u_4
β₁ : Type u_5
β₂ : Type u_6
γ₁ : Type u_2
γ₂ : Type u_1
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ ¬∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ inl c₁ = inr c₂ ∧ c₂ ∈ g a₂ b₂

tactic: rintro ⟨_, _, c₂, _, _, h, _⟩
state_before: α₁ : Type u_3
α₂ : Type u_4
β₁ : Type u_5
β₂ : Type u_6
γ₁ : Type u_2
γ₂ : Type u_1
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ ¬∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ inl c₁ = inr c₂ ∧ c₂ ∈ g a₂ b₂

tactic: exact inl_ne_inr h
state_before: case intro.intro.intro.intro.intro.intro
α₁ : Type u_3
α₂ : Type u_4
β₁ : Type u_5
β₂ : Type u_6
γ₁ : Type u_2
γ₂ : Type u_1
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
w✝¹ : α₂
w✝ : β₂
c₂ : γ₂
left✝¹ : a = inr w✝¹
left✝ : b = inr w✝
h : inl c₁ = inr c₂
right✝ : c₂ ∈ g w✝¹ w✝
⊢ False
Theorem: Nat.bit0_le_bit1_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rwa [← Nat.lt_succ_iff, n.bit1_eq_succ_bit0,
← n.bit0_succ_eq, bit0_lt_bit0, Nat.lt_succ_iff] at h
state_before: m n k l : ℕ
h : bit0 m ≤ bit1 n
⊢ m ≤ n
Theorem: hasDerivAt_circleMap
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simpa only [mul_assoc, one_mul, ofRealClm_apply, circleMap, ofReal_one, zero_add]
  using (((ofRealClm.hasDerivAt (x := θ)).mul_const I).cexp.const_mul (R : ℂ)).const_add c
state_before: E : Type ?u.21873
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ HasDerivAt (circleMap c R) (circleMap 0 R θ * I) θ