1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Integrable.inf
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf hg ⊢
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Integrable f μ
hg : Integrable g μ
⊢ Integrable (f ⊓ g) μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊓ g) 1 μ

tactic: exact hf.inf hg
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊓ g) 1 μ
state_after: no goals
Theorem: UpperSet.map_map
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : UpperSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
⊢ (map g) ((map f) s) = (map (f.trans g)) s
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : UpperSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
x✝ : γ
⊢ x✝ ∈ ↑((map g) ((map f) s)) ↔ x✝ ∈ ↑((map (f.trans g)) s)

tactic: simp
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : UpperSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
x✝ : γ
⊢ x✝ ∈ ↑((map g) ((map f) s)) ↔ x✝ ∈ ↑((map (f.trans g)) s)
state_after: no goals
Theorem: PiNat.firstDiff_comm
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp only [firstDiff_def, ne_comm]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ firstDiff x y = firstDiff y x
state_after: no goals
Theorem: DFinsupp.mapRange_add
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y
g₁ g₂ : Π₀ (i : ι), β₁ i
⊢ mapRange f hf (g₁ + g₂) = mapRange f hf g₁ + mapRange f hf g₂
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y
g₁ g₂ : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ (mapRange f hf (g₁ + g₂)) i✝ = (mapRange f hf g₁ + mapRange f hf g₂) i✝

tactic: simp only [mapRange_apply f, coe_add, Pi.add_apply, hf']
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y
g₁ g₂ : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ (mapRange f hf (g₁ + g₂)) i✝ = (mapRange f hf g₁ + mapRange f hf g₂) i✝
state_after: no goals
Theorem: Subgroup.map_normalClosure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: have : Normal (map f (normalClosure s)) := Normal.map inferInstance f hf
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
⊢ map f (normalClosure s) = normalClosure (⇑f '' s)
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) = normalClosure (⇑f '' s)

tactic: apply le_antisymm
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) = normalClosure (⇑f '' s)
state_after: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) ≤ normalClosure (⇑f '' s)

case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ normalClosure (⇑f '' s) ≤ map f (normalClosure s)

tactic: simp [map_le_iff_le_comap, normalClosure_le_normal, coe_comap,
  ← Set.image_subset_iff, subset_normalClosure]
state_before: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) ≤ normalClosure (⇑f '' s)
state_after: no goals

tactic: exact normalClosure_le_normal (Set.image_subset f subset_normalClosure)
state_before: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ normalClosure (⇑f '' s) ≤ map f (normalClosure s)
state_after: no goals
Theorem: CategoryTheory.Bicategory.unitors_inv_equal
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [Iso.inv_eq_inv]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
⊢ (λ_ (𝟙 a)).inv = (ρ_ (𝟙 a)).inv
state_after: no goals
Theorem: Order.le_succ_bot_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm]
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : OrderBot α
⊢ a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥
state_after: no goals
Theorem: irrational_int_mul_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_intCast, irrational_rat_mul_iff, Int.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑m * x) ↔ m ≠ 0 ∧ Irrational x
state_after: no goals
Theorem: ScottContinuous.monotone
File: Mathlib/Order/Bounds/Basic.lean

tactic: refine fun a b hab =>
  (h (insert_nonempty _ _) (directedOn_pair le_refl hab) ?_).1
    (mem_image_of_mem _ <| mem_insert _ _)
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a : α
h : ScottContinuous f
⊢ Monotone f
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a✝ : α
h : ScottContinuous f
a b : α
hab : a ≤ b
⊢ IsLUB {a, b} b

tactic: rw [IsLUB, upperBounds_insert, upperBounds_singleton,
  inter_eq_self_of_subset_right (Ici_subset_Ici.2 hab)]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a✝ : α
h : ScottContinuous f
a b : α
hab : a ≤ b
⊢ IsLUB {a, b} b
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a✝ : α
h : ScottContinuous f
a b : α
hab : a ≤ b
⊢ IsLeast (Ici b) b

tactic: exact isLeast_Ici
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a✝ : α
h : ScottContinuous f
a b : α
hab : a ≤ b
⊢ IsLeast (Ici b) b
state_after: no goals
Theorem: Set.MapsTo.iterate_restrict
File: Mathlib/Data/Set/Function.lean

tactic: funext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
⊢ (restrict f s s h)^[n] = restrict f^[n] s s ⋯
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ (restrict f s s h)^[n] x = restrict f^[n] s s ⋯ x

tactic: rw [Subtype.ext_iff, MapsTo.val_restrict_apply]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ (restrict f s s h)^[n] x = restrict f^[n] s s ⋯ x
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ ↑((restrict f s s h)^[n] x) = f^[n] ↑x

tactic: induction' n with n ihn generalizing x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ ↑((restrict f s s h)^[n] x) = f^[n] ↑x
state_after: case h.zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
x : ↑s
⊢ ↑((restrict f s s h)^[0] x) = f^[0] ↑x

case h.succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
ihn : ∀ (x : ↑s), ↑((restrict f s s h)^[n] x) = f^[n] ↑x
x : ↑s
⊢ ↑((restrict f s s h)^[n + 1] x) = f^[n + 1] ↑x

tactic: rfl
state_before: case h.zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
x : ↑s
⊢ ↑((restrict f s s h)^[0] x) = f^[0] ↑x
state_after: no goals

tactic: simp [Nat.iterate, ihn]
state_before: case h.succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
ihn : ∀ (x : ↑s), ↑((restrict f s s h)^[n] x) = f^[n] ↑x
x : ↑s
⊢ ↑((restrict f s s h)^[n + 1] x) = f^[n + 1] ↑x
state_after: no goals
Theorem: MulAction.smul_fixedBy
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

tactic: ext a
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
⊢ h • fixedBy α g = fixedBy α (h * g * h⁻¹)
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
a : α
⊢ a ∈ h • fixedBy α g ↔ a ∈ fixedBy α (h * g * h⁻¹)

tactic: simp_rw [Set.mem_smul_set_iff_inv_smul_mem, mem_fixedBy, mul_smul, smul_eq_iff_eq_inv_smul h]
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
a : α
⊢ a ∈ h • fixedBy α g ↔ a ∈ fixedBy α (h * g * h⁻¹)
state_after: no goals
Theorem: oneLePart_div_leOnePart
File: Mathlib/Algebra/Order/Group/PosPart.lean

tactic: rw [div_eq_mul_inv, mul_inv_eq_iff_eq_mul, leOnePart, mul_sup, mul_one, mul_right_inv, sup_comm,
  oneLePart]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Lattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ a : α
⊢ a⁺ᵐ / a⁻ᵐ = a
state_after: no goals
Theorem: EuclideanGeometry.tan_angle_mul_dist_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₂
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂
state_after: 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₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂

tactic: rw [ne_comm, ← @vsub_ne_zero V, ← @vsub_eq_zero_iff_eq V, or_comm] 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 : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂
state_after: 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₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0 ∨ p₁ -ᵥ p₂ = 0
⊢ Real.tan (∠ p₂ p₃ p₁) * 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, tan_angle_add_mul_norm_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 : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0 ∨ p₁ -ᵥ p₂ = 0
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂
state_after: no goals
Theorem: NumberField.Embeddings.card
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [Fintype.ofEquiv_card RingHom.equivRatAlgHom.symm, AlgHom.card]
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : Field A
inst✝¹ : CharZero A
inst✝ : IsAlgClosed A
⊢ Fintype.card (K →+* A) = finrank ℚ K
state_after: no goals
Theorem: rTensor.inverse_comp_rTensor
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

tactic: rw [rTensor.inverse, rTensor.inverse_of_rightInverse_comp_rTensor]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
⊢ inverse Q hfg hg ∘ₗ rTensor Q g = (range (rTensor Q f)).mkQ
state_after: no goals
Theorem: Matroid.loopyOn_restrict
File: Mathlib/Data/Matroid/Constructions.lean

tactic: refine eq_of_indep_iff_indep_forall rfl ?_
state_before: α : Type u_1
M : Matroid α
E✝ B I X R✝ J E R : Set α
⊢ loopyOn E ↾ R = loopyOn R
state_after: α : Type u_1
M : Matroid α
E✝ B I X R✝ J E R : Set α
⊢ ∀ I ⊆ (loopyOn E ↾ R).E, (loopyOn E ↾ R).Indep I ↔ (loopyOn R).Indep I

tactic: simp only [restrict_ground_eq, restrict_indep_iff, loopyOn_indep_iff, and_iff_left_iff_imp]
state_before: α : Type u_1
M : Matroid α
E✝ B I X R✝ J E R : Set α
⊢ ∀ I ⊆ (loopyOn E ↾ R).E, (loopyOn E ↾ R).Indep I ↔ (loopyOn R).Indep I
state_after: α : Type u_1
M : Matroid α
E✝ B I X R✝ J E R : Set α
⊢ ∀ I ⊆ R, I = ∅ → I ⊆ R

tactic: exact fun _ h _ ↦ h
state_before: α : Type u_1
M : Matroid α
E✝ B I X R✝ J E R : Set α
⊢ ∀ I ⊆ R, I = ∅ → I ⊆ R
state_after: no goals
Theorem: Nat.coprime_prod_right_iff
File: Mathlib/Data/Nat/GCD/BigOperators.lean

tactic: simpa using coprime_multiset_prod_right_iff (m := t.val.map s)
state_before: ι : Type u_1
x : ℕ
t : Finset ι
s : ι → ℕ
⊢ x.Coprime (∏ i ∈ t, s i) ↔ ∀ i ∈ t, x.Coprime (s i)
state_after: no goals
Theorem: Module.finite_of_finrank_pos
File: Mathlib/LinearAlgebra/Dimension/Free.lean

tactic: contrapose h
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Free R M₁
h : 0 < finrank R M
⊢ Finite R M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Free R M₁
h : ¬Finite R M
⊢ ¬0 < finrank R M

tactic: simp [finrank_of_not_finite h]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Free R M₁
h : ¬Finite R M
⊢ ¬0 < finrank R M
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.pair_preimage_singleton
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [← singleton_prod_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : α →ₛ γ
b : β
c : γ
⊢ ↑(f.pair g) ⁻¹' {(b, c)} = ↑f ⁻¹' {b} ∩ ↑g ⁻¹' {c}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : α →ₛ γ
b : β
c : γ
⊢ ↑(f.pair g) ⁻¹' {b} ×ˢ {c} = ↑f ⁻¹' {b} ∩ ↑g ⁻¹' {c}

tactic: exact pair_preimage _ _ _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : α →ₛ γ
b : β
c : γ
⊢ ↑(f.pair g) ⁻¹' {b} ×ˢ {c} = ↑f ⁻¹' {b} ∩ ↑g ⁻¹' {c}
state_after: no goals
Theorem: Nat.bodd_add
File: Mathlib/Data/Nat/Bits.lean

tactic: induction n
state_before: m✝ n✝ m n : ℕ
⊢ (m + n).bodd = bxor m.bodd n.bodd
state_after: case zero
m✝ n m : ℕ
⊢ (m + 0).bodd = bxor m.bodd (bodd 0)

case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd

tactic: case zero => simp
state_before: case zero
m✝ n m : ℕ
⊢ (m + 0).bodd = bxor m.bodd (bodd 0)

case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
state_after: case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd

tactic: case succ n ih => simp [← Nat.add_assoc, Bool.xor_not, ih]
state_before: case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
state_after: no goals

tactic: simp
state_before: m✝ n m : ℕ
⊢ (m + 0).bodd = bxor m.bodd (bodd 0)
state_after: no goals

tactic: simp [← Nat.add_assoc, Bool.xor_not, ih]
state_before: m✝ n✝ m n : ℕ
ih : (m + n).bodd = bxor m.bodd n.bodd
⊢ (m + (n + 1)).bodd = bxor m.bodd (n + 1).bodd
state_after: no goals
Theorem: Batteries.OrientedCmp.cmp_eq_gt
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: rw [← Ordering.swap_inj, symm]
state_before: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
x y : α✝
inst✝ : OrientedCmp cmp
⊢ cmp x y = Ordering.gt ↔ cmp y x = Ordering.lt
state_after: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
x y : α✝
inst✝ : OrientedCmp cmp
⊢ cmp y x = Ordering.gt.swap ↔ cmp y x = Ordering.lt

tactic: exact .rfl
state_before: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
x y : α✝
inst✝ : OrientedCmp cmp
⊢ cmp y x = Ordering.gt.swap ↔ cmp y x = Ordering.lt
state_after: no goals
Theorem: Real.Angle.pi_div_two_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_injective.ne_iff, toReal_pi_div_two, toReal_zero]
state_before: ⊢ ↑(π / 2) ≠ 0
state_after: ⊢ π / 2 ≠ 0

tactic: exact div_ne_zero Real.pi_ne_zero two_ne_zero
state_before: ⊢ π / 2 ≠ 0
state_after: no goals
Theorem: CategoryTheory.SplitMono.mono
File: Mathlib/CategoryTheory/EpiMono.lean

tactic: replace w := w =≫ sm.retraction
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
sm : SplitMono f
Z✝ : C
g h : Z✝ ⟶ X
w : g ≫ f = h ≫ f
⊢ g = h
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
sm : SplitMono f
Z✝ : C
g h : Z✝ ⟶ X
w : (g ≫ f) ≫ sm.retraction = (h ≫ f) ≫ sm.retraction
⊢ g = h

tactic: simpa using w
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
sm : SplitMono f
Z✝ : C
g h : Z✝ ⟶ X
w : (g ≫ f) ≫ sm.retraction = (h ≫ f) ≫ sm.retraction
⊢ g = h
state_after: no goals
Theorem: CategoryTheory.Limits.kernelSubobject_factors
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ kernel.lift f h w ≫ (MonoOver.mk' (kernel.ι f)).arrow = h
state_after: no goals
Theorem: tendsto_inv_nhdsWithin_Iic_inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa only [inv_inv] using @tendsto_inv_nhdsWithin_Iic _ _ _ _ a⁻¹
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto Inv.inv (𝓝[≤] a⁻¹) (𝓝[≥] a)
state_after: no goals
Theorem: EReal.mul_div_cancel
File: Mathlib/Data/Real/EReal.lean

tactic: rw [mul_comm, div_mul_cancel h₁ h₂ h₃]
state_before: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ b * (a / b) = a
state_after: no goals
Theorem: padicValNat.pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simpa only [← @Nat.cast_inj ℤ, push_cast] using padicValRat.pow (Nat.cast_ne_zero.mpr ha)
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
ha : a ≠ 0
⊢ padicValNat p (a ^ n) = n * padicValNat p a
state_after: no goals