tasksource/leandojo huggingface dataset:
Theorem: TopCat.pullbackIsoProdSubtype_hom_apply
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: simpa using ConcreteCategory.congr_hom pullback.condition x
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (forget TopCat).map f ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).fst =
    (forget TopCat).map g ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).snd

tactic: apply Subtype.ext
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (forget TopCat).map (pullbackIsoProdSubtype f g).hom x =
    { val := ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x),
      property :=
        (_ :
          (forget TopCat).map f ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).fst =
            (forget TopCat).map g ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).snd) }

tactic: apply Prod.ext
state_before: case a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ ↑((forget TopCat).map (pullbackIsoProdSubtype f g).hom x) =
    ↑{ val := ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x),
        property :=
          (_ :
            (forget TopCat).map f ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).fst =
              (forget TopCat).map g ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).snd) }

tactic: exacts [ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_fst f g) x,
  ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_snd f g) x]
state_before: case a.h₁
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((forget TopCat).map (pullbackIsoProdSubtype f g).hom x)).fst =
    (↑{ val := ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x),
          property :=
            (_ :
              (forget TopCat).map f ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).fst =
                (forget TopCat).map g
                  ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).snd) }).fst

case a.h₂
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((forget TopCat).map (pullbackIsoProdSubtype f g).hom x)).snd =
    (↑{ val := ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x),
          property :=
            (_ :
              (forget TopCat).map f ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).fst =
                (forget TopCat).map g
                  ((forget TopCat).map pullback.fst x, (forget TopCat).map pullback.snd x).snd) }).snd
Theorem: CategoryTheory.Functor.preservesEpimorphsisms_of_adjunction
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: intro Z g h H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
⊢ ∀ {Z : D} (g h : F.obj Y ⟶ Z), F.map f ≫ g = F.map f ≫ h → g = h

tactic: replace H := congr_arg (adj.homEquiv X Z) H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : F.map f ≫ g = F.map f ≫ h
⊢ g = h

tactic: rwa [adj.homEquiv_naturality_left, adj.homEquiv_naturality_left, cancel_epi,
  Equiv.apply_eq_iff_eq] at H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : ↑(Adjunction.homEquiv adj X Z) (F.map f ≫ g) = ↑(Adjunction.homEquiv adj X Z) (F.map f ≫ h)
⊢ g = h
Theorem: MeasureTheory.SimpleFunc.mem_image_of_mem_range_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simpa [mem_restrict_range hs, h0, -mem_range] using hr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.814900
δ : Type ?u.814903
inst✝¹ : MeasurableSpace α
K : Type ?u.814909
inst✝ : Zero β
r : β
s : Set α
f : α →ₛ β
hr : r ∈ SimpleFunc.range (restrict f s)
h0 : r ≠ 0
hs : MeasurableSet s
⊢ r ∈ ↑f '' s

tactic: rw [restrict_of_not_measurable hs] at hr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.814900
δ : Type ?u.814903
inst✝¹ : MeasurableSpace α
K : Type ?u.814909
inst✝ : Zero β
r : β
s : Set α
f : α →ₛ β
hr : r ∈ SimpleFunc.range (restrict f s)
h0 : r ≠ 0
hs : ¬MeasurableSet s
⊢ r ∈ ↑f '' s

tactic: exact (h0 <| eq_zero_of_mem_range_zero hr).elim
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.814900
δ : Type ?u.814903
inst✝¹ : MeasurableSpace α
K : Type ?u.814909
inst✝ : Zero β
r : β
s : Set α
f : α →ₛ β
hr : r ∈ SimpleFunc.range 0
h0 : r ≠ 0
hs : ¬MeasurableSet s
⊢ r ∈ ↑f '' s
Theorem: gcd_eq_of_dvd_sub_right
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: apply dvd_antisymm_of_normalize_eq (normalize_gcd _ _) (normalize_gcd _ _) <;>
  rw [dvd_gcd_iff] <;>
  refine' ⟨gcd_dvd_left _ _, _⟩
state_before: α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a b = gcd a c

tactic: rcases h with ⟨d, hd⟩
state_before: case hab
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a b ∣ c

tactic: rcases gcd_dvd_right a b with ⟨e, he⟩
state_before: case hab.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
⊢ gcd a b ∣ c

tactic: rcases gcd_dvd_left a b with ⟨f, hf⟩
state_before: case hab.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : b = gcd a b * e
⊢ gcd a b ∣ c

tactic: use e - f * d
state_before: case hab.intro.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : b = gcd a b * e
f : α
hf : a = gcd a b * f
⊢ gcd a b ∣ c

tactic: rw [mul_sub, ← he, ← mul_assoc, ← hf, ← hd, sub_sub_cancel]
state_before: case hab.intro.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : b = gcd a b * e
f : α
hf : a = gcd a b * f
⊢ c = gcd a b * (e - f * d)

tactic: rcases h with ⟨d, hd⟩
state_before: case hba
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a c ∣ b

tactic: rcases gcd_dvd_right a c with ⟨e, he⟩
state_before: case hba.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
⊢ gcd a c ∣ b

tactic: rcases gcd_dvd_left a c with ⟨f, hf⟩
state_before: case hba.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : c = gcd a c * e
⊢ gcd a c ∣ b

tactic: use e + f * d
state_before: case hba.intro.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : c = gcd a c * e
f : α
hf : a = gcd a c * f
⊢ gcd a c ∣ b

tactic: rw [mul_add, ← he, ← mul_assoc, ← hf, ← hd, ← add_sub_assoc, add_comm c b, add_sub_cancel]
state_before: case hba.intro.intro.intro
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c d : α
hd : b - c = a * d
e : α
he : c = gcd a c * e
f : α
hf : a = gcd a c * f
⊢ b = gcd a c * (e + f * d)
Theorem: IsPrimitiveRoot.geom_sum_eq_zero
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: refine' eq_zero_of_ne_zero_of_mul_left_eq_zero (sub_ne_zero_of_ne (hζ.ne_one hk).symm) _
state_before: M : Type ?u.2777832
N : Type ?u.2777835
G : Type ?u.2777838
R : Type u_1
S : Type ?u.2777844
F : Type ?u.2777847
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ ∑ i in range k, ζ ^ i = 0

tactic: rw [mul_neg_geom_sum, hζ.pow_eq_one, sub_self]
state_before: M : Type ?u.2777832
N : Type ?u.2777835
G : Type ?u.2777838
R : Type u_1
S : Type ?u.2777844
F : Type ?u.2777847
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ (1 - ζ) * ∑ i in range k, ζ ^ i = 0
Theorem: LinearMap.eq_adjoint_iff
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: refine' ⟨fun h x y => by rw [h, adjoint_inner_left], fun h => _⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1931672
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
⊢ A = ↑adjoint B ↔ ∀ (x : E) (y : (fun x => F) x), inner (↑A x) y = inner x (↑B y)

tactic: ext x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1931672
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : (fun x => F) x), inner (↑A x) y = inner x (↑B y)
⊢ A = ↑adjoint B

tactic: exact ext_inner_right 𝕜 fun y => by simp only [adjoint_inner_left, h x y]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1931672
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : (fun x => F) x), inner (↑A x) y = inner x (↑B y)
x : E
⊢ ↑A x = ↑(↑adjoint B) x

tactic: rw [h, adjoint_inner_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1931672
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : A = ↑adjoint B
x : E
y : (fun x => F) x
⊢ inner (↑A x) y = inner x (↑B y)

tactic: simp only [adjoint_inner_left, h x y]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1931672
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : (fun x => F) x), inner (↑A x) y = inner x (↑B y)
x : E
y : (fun x => F) x
⊢ inner (↑A x) y = inner (↑(↑adjoint B) x) y
Theorem: Convex.linear_preimage
File: Mathlib/Analysis/Convex/Basic.lean

tactic: intro x hx y hy a b ha hb hab
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
β : Type ?u.40424
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s✝ : Set E
x : E
s : Set F
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
⊢ Convex 𝕜 (↑f ⁻¹' s)

tactic: rw [mem_preimage, f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
β : Type ?u.40424
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s✝ : Set E
x✝ : E
s : Set F
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
x : E
hx : x ∈ ↑f ⁻¹' s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ ↑f ⁻¹' s

tactic: exact hs hx hy ha hb hab
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
β : Type ?u.40424
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s✝ : Set E
x✝ : E
s : Set F
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
x : E
hx : x ∈ ↑f ⁻¹' s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • ↑f x + b • ↑f y ∈ s
Theorem: Polynomial.eval₂_bit0
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [bit0, eval₂_add, bit0]
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]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ eval₂ f x (bit0 p) = bit0 (eval₂ f x p)
Theorem: ZNum.cast_add
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases a <;> exact (_root_.zero_add _).symm
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a : ZNum
⊢ ↑(0 + a) = ↑0 + ↑a

tactic: cases b <;> exact (_root_.add_zero _).symm
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
b : ZNum
⊢ ↑(b + 0) = ↑b + ↑0

tactic: simpa only [sub_eq_add_neg] using PosNum.cast_sub' (α := α) _ _
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a b : PosNum
⊢ ↑(pos a + neg b) = ↑(pos a) + ↑(neg b)

tactic: rw [← PosNum.cast_to_int a, ← PosNum.cast_to_int b, ← Int.cast_neg, ← Int.cast_add (-a)]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a b : PosNum
⊢ ↑b + -↑a = -↑a + ↑b

tactic: simp [add_comm]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a b : PosNum
⊢ ↑↑b + ↑(-↑a) = ↑(-↑a + ↑b)

tactic: rw [PosNum.cast_add, neg_eq_iff_eq_neg, neg_add_rev, neg_neg, neg_neg,
    ← PosNum.cast_to_int a, ← PosNum.cast_to_int b, ← Int.cast_add, ← Int.cast_add, add_comm]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a b : PosNum
⊢ -↑(a + b) = -↑a + -↑b
Theorem: Nat.Linear.Poly.denote_eq_cancel
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (m₁, m₂)
⊢ denote_eq ctx (cancel m₁ m₂)

tactic: apply denote_eq_cancelAux
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (m₁, m₂)
⊢ denote_eq ctx (cancel m₁ m₂)

tactic: simp [h]
state_before: case h
ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (m₁, m₂)
⊢ denote_eq ctx (List.reverse [] ++ m₁, List.reverse [] ++ m₂)
Theorem: EuclideanGeometry.angle_sub_const
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: simpa only [vsub_eq_sub] using angle_vsub_const v₁ v₂ v₃ v
state_before: V : Type u_1
P : Type ?u.38982
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v₁ v₂ v₃ v : V
⊢ ∠ (v₁ - v) (v₂ - v) (v₃ - v) = ∠ v₁ v₂ v₃
Theorem: UniformInducing.comp
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [← hf.1, ← hg.1, comap_comap]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
g : β → γ
hg : UniformInducing g
f : α → β
hf : UniformInducing f
⊢ comap (fun x => ((g ∘ f) x.fst, (g ∘ f) x.snd)) (𝓤 γ) = 𝓤 α

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
g : β → γ
hg : UniformInducing g
f : α → β
hf : UniformInducing f
⊢ comap (fun x => ((g ∘ f) x.fst, (g ∘ f) x.snd)) (𝓤 γ) =
    comap ((fun x => (g x.fst, g x.snd)) ∘ fun x => (f x.fst, f x.snd)) (𝓤 γ)
Theorem: Matrix.invOf_eq_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := detInvertibleOfInvertible A
state_before: l : Type ?u.127855
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
⊢ ⅟A = A⁻¹

tactic: rw [inv_def, Ring.inverse_invertible, invOf_eq]
state_before: l : Type ?u.127855
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
this : Invertible (det A) := detInvertibleOfInvertible A
⊢ ⅟A = A⁻¹
Theorem: List.isRotated_next_eq
File: Mathlib/Data/List/Cycle.lean

tactic: obtain ⟨k, hk, rfl⟩ := nthLe_of_mem hx
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l l' : List α
h : l ~r l'
hn : Nodup l
x : α
hx : x ∈ l
⊢ next l x hx = next l' x (_ : x ∈ l')

tactic: obtain ⟨n, rfl⟩ := id h
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l l' : List α
h : l ~r l'
hn : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
⊢ next l (nthLe l k hk) hx = next l' (nthLe l k hk) (_ : nthLe l k hk ∈ l')

tactic: rw [next_nthLe _ hn]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
n : ℕ
h : l ~r rotate l n
⊢ next l (nthLe l k hk) hx = next (rotate l n) (nthLe l k hk) (_ : nthLe l k hk ∈ rotate l n)

tactic: simp_rw [← nthLe_rotate' _ n k]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
n : ℕ
h : l ~r rotate l n
⊢ nthLe l ((k + 1) % length l) (_ : (k + 1) % length l < length l) =
    next (rotate l n) (nthLe l k hk) (_ : nthLe l k hk ∈ rotate l n)

tactic: rw [next_nthLe _ (h.nodup_iff.mp hn), ← nthLe_rotate' _ n]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
n : ℕ
h : l ~r rotate l n
⊢ nthLe l ((k + 1) % length l) (_ : (k + 1) % length l < length l) =
    next (rotate l n)
      (nthLe (rotate l n) ((length l - n % length l + k) % length l)
        (_ : (length l - n % length l + k) % length l < length (rotate l n)))
      (_ :
        nthLe (rotate l n) ((length l - n % length l + k) % length l)
            (_ : (length l - n % length l + k) % length l < length (rotate l n)) ∈
          rotate l n)

tactic: simp [add_assoc]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
n : ℕ
h : l ~r rotate l n
⊢ nthLe (rotate l n) ((length l - n % length l + (k + 1) % length l) % length l)
      (_ : (length l - n % length l + (k + 1) % length l) % length l < length (rotate l n)) =
    nthLe (rotate l n) (((length l - n % length l + k) % length l + 1) % length (rotate l n))
      (_ : ((length l - n % length l + k) % length l + 1) % length (rotate l n) < length (rotate l n))
Theorem: Fin.coe_cast
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n m : ℕ
h : n = m
i : Fin n
⊢ ↑(↑(cast h) i) = ↑i
Theorem: Set.union_distrib_iInter₂_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [union_distrib_iInter_left]
state_before: α : Type u_1
β : Type ?u.181670
γ : Type ?u.181673
ι : Sort u_2
ι' : Sort ?u.181679
ι₂ : Sort ?u.181682
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.181692
κ₂ : ι → Sort ?u.181697
κ' : ι' → Sort ?u.181702
s : Set α
t : (i : ι) → κ i → Set α
⊢ (s ∪ ⋂ (i : ι) (j : κ i), t i j) = ⋂ (i : ι) (j : κ i), s ∪ t i j
Theorem: IsCompactOperator.image_subset_compact_of_bounded
File: Mathlib/Analysis/NormedSpace/CompactOperator.lean

tactic: rwa [NormedSpace.isVonNBounded_iff, ← Metric.bounded_iff_isBounded]
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜₁
inst✝⁶ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_4
M₂ : Type u_2
M₃ : Type ?u.72218
inst✝⁵ : SeminormedAddCommGroup M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : NormedSpace 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ↑f
S : Set M₁
hS : Metric.Bounded S
⊢ IsVonNBounded 𝕜₁ S
Theorem: Prod.swap_iSup
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [iSup, swap_sSup, ←range_comp, Function.comp]
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.212863
γ : Type ?u.212866
ι : Sort u_3
ι' : Sort ?u.212872
κ : ι → Sort ?u.212877
κ' : ι' → Sort ?u.212882
inst✝¹ : SupSet α
inst✝ : SupSet β
f : ι → α × β
⊢ swap (iSup f) = ⨆ (i : ι), swap (f i)
Theorem: lowerSemicontinuousWithinAt_tsum
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp_rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type ?u.131928
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_2
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) s x
⊢ LowerSemicontinuousWithinAt (fun x' => ∑' (i : ι), f i x') s x

tactic: refine lowerSemicontinuousWithinAt_iSup fun b => ?_
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type ?u.131928
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_2
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) s x
⊢ LowerSemicontinuousWithinAt (fun x' => ⨆ (s : Finset ι), ∑ i in s, f i x') s x

tactic: exact lowerSemicontinuousWithinAt_sum fun i _hi => h i
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type ?u.131928
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_2
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) s x
b : Finset ι
⊢ LowerSemicontinuousWithinAt (fun x' => ∑ i in b, f i x') s x