auslander 0.9.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
use super::*;
use crate::algebra::{Algebra, an_with_relations, linear_an};
use crate::basic::{AddClosureWitness, BasicDecomposition};
use crate::endo::EndoAlgebra;
use crate::field::PrimeField;
use crate::hom::{identity, zero_morphism};
use crate::homotopy::{BoundedComplex, ChainHomotopy, ChainMap};
use crate::module::{Module, direct_sum};
use crate::resolution::{ResolutionEnd, resolve};
use crate::target::{
    TargetLimits, TargetPresentationOutcome, VerifiedTargetPresentation, present_target,
};
use crate::tilting::{ClassicalTiltingModule, ClassicalTiltingResult, TiltingLimits};
use std::sync::Arc;

fn f5() -> PrimeField {
    PrimeField::new(5).expect("5 is prime")
}

fn f2() -> PrimeField {
    PrimeField::new(2).expect("2 is prime")
}

fn regular(algebra: &Arc<Algebra>) -> Module {
    let projectives: Vec<Module> = (0..algebra.quiver().num_vertices())
        .map(|vertex| Module::projective(algebra, vertex))
        .collect();
    direct_sum(&projectives.iter().collect::<Vec<_>>()).0
}

fn strict_regular_transport() -> (StrictTransport, Module) {
    let algebra = linear_an(2, f5());
    let module = regular(&algebra);
    let limits = TiltingLimits {
        max_projective_dimension: 4,
        max_generation_steps: 8,
    };
    let ClassicalTiltingResult::Tilting(tilting) =
        ClassicalTiltingModule::classify(&module, limits).expect("fixture classifies")
    else {
        panic!("the regular module is classical tilting")
    };
    let TargetPresentationOutcome::Presented(target) =
        present_target(&tilting, &TargetLimits::default()).expect("target completes")
    else {
        panic!("the regular target is split")
    };
    (
        StrictTransport::new(target).expect("strict transport builds"),
        module,
    )
}

fn regular_certificate_inputs() -> (ClassicalTiltingModule, VerifiedTargetPresentation) {
    let algebra = linear_an(2, f5());
    let module = regular(&algebra);
    let limits = TiltingLimits {
        max_projective_dimension: 4,
        max_generation_steps: 8,
    };
    let ClassicalTiltingResult::Tilting(tilting) =
        ClassicalTiltingModule::classify(&module, limits).expect("fixture classifies")
    else {
        panic!("the regular module is classical tilting")
    };
    let TargetPresentationOutcome::Presented(target) =
        present_target(&tilting, &TargetLimits::default()).expect("target completes")
    else {
        panic!("the regular target is split")
    };
    (tilting, target)
}

#[test]
fn regular_generator_transports_one_term_in_both_directions() {
    let (transport, module) = strict_regular_transport();
    let basic = BasicDecomposition::new(&module).expect("regular module is basic");
    let witness = AddClosureWitness::from_module(&module, &basic)
        .expect("membership decomposes")
        .expect("T lies in add(T)");
    let source = AddTComplex::new(
        BoundedComplex::new(0, vec![module], Vec::new()).expect("one term is a complex"),
        vec![witness],
    )
    .expect("witnessed source builds");
    let target = transport
        .forward(&source)
        .expect("forward transport builds");
    assert!(target.verify());
    let back = transport
        .reverse(&target)
        .expect("reverse transport builds");
    assert!(back.verify());
    assert!(transport.source_round_trip(&source).is_ok());
    assert!(transport.target_round_trip(&target).is_ok());
}

#[test]
fn regular_generator_transports_a_chain_map_and_round_trip() {
    let (transport, module) = strict_regular_transport();
    let basic = BasicDecomposition::new(&module).expect("regular module is basic");
    let witness = AddClosureWitness::from_module(&module, &basic)
        .expect("membership decomposes")
        .expect("T lies in add(T)");
    let complex = BoundedComplex::new(
        0,
        vec![module.clone(), module.clone()],
        vec![identity(&module)],
    )
    .expect("identity is a one-step complex");
    let source = AddTComplex::new(complex.clone(), vec![witness.clone(), witness])
        .expect("witnessed source builds");
    let map = ChainMap::identity(&complex);
    assert!(transport.forward_chain_map(&source, &source, &map).is_ok());
    let target = transport
        .forward(&source)
        .expect("forward transport builds");
    assert!(
        transport
            .reverse_chain_map(&target, &target, &ChainMap::identity(target.complex()))
            .is_ok()
    );
    assert!(transport.source_round_trip(&source).is_ok());
}

#[test]
fn transport_normalizes_unequal_chain_supports_before_mapping() {
    let (transport, module) = strict_regular_transport();
    let basic = BasicDecomposition::new(&module).expect("regular module is basic");
    let witness = AddClosureWitness::from_module(&module, &basic)
        .expect("membership decomposes")
        .expect("T lies in add(T)");
    let low = AddTComplex::new(
        BoundedComplex::new(0, vec![module.clone()], Vec::new()).expect("one term is a complex"),
        vec![witness.clone()],
    )
    .expect("lower source builds");
    let high = AddTComplex::new(
        BoundedComplex::new(1, vec![module.clone()], Vec::new()).expect("one term is a complex"),
        vec![witness],
    )
    .expect("upper source builds");
    let map =
        ChainMap::zero(low.complex(), high.complex()).expect("the offset zero map is a chain map");
    assert_eq!((map.range().lower(), map.range().upper()), (0, 1));
    let target_map = transport
        .forward_chain_map(&low, &high, &map)
        .expect("forward map accepts padded support");
    assert!(target_map.verify());
    let low_target = transport.forward(&low).expect("lower target builds");
    let high_target = transport.forward(&high).expect("upper target builds");
    let reverse_map = transport
        .reverse_chain_map(&low_target, &high_target, &target_map)
        .expect("reverse map accepts padded support");
    assert!(reverse_map.verify());

    let homotopy = ChainHomotopy::new(low.complex(), high.complex(), vec![identity(&module)])
        .expect("the offset identity is a homotopy component");
    let target_homotopy = transport
        .forward_homotopy(&low, &high, &homotopy)
        .expect("forward homotopy accepts padded support");
    assert!(target_homotopy.verify());
    let reverse_homotopy = transport
        .reverse_homotopy(&low_target, &high_target, &target_homotopy)
        .expect("reverse homotopy accepts padded support");
    assert!(reverse_homotopy.verify());

    assert!(transport.forward_cone(&low, &high, &map).is_ok());
    assert!(
        transport
            .reverse_cone(&low_target, &high_target, &target_map)
            .is_ok()
    );
}

#[test]
fn regular_generator_has_a_verified_derived_certificate() {
    let (tilting, target) = regular_certificate_inputs();
    let certificate = DerivedEquivalenceCertificate::new(tilting, target)
        .expect("regular generator has a certificate");
    assert!(certificate.verify());
    assert_eq!(certificate.graded_homotopy().len(), 1);
    assert_eq!(
        certificate.degree_zero_identification().quotient().dim(),
        certificate.target().endo().dim()
    );
}

#[test]
fn projective_dimension_one_tilting_module_has_a_certificate() {
    let algebra = linear_an(2, f5());
    let p0 = Module::projective(&algebra, 0);
    let s0 = Module::simple(&algebra, 0);
    let module = direct_sum(&[&p0, &s0]).0;
    let limits = TiltingLimits {
        max_projective_dimension: 4,
        max_generation_steps: 8,
    };
    let ClassicalTiltingResult::Tilting(tilting) =
        ClassicalTiltingModule::classify(&module, limits).expect("fixture classifies")
    else {
        panic!("the fixture is classical tilting")
    };
    let TargetPresentationOutcome::Presented(target) =
        present_target(&tilting, &TargetLimits::default()).expect("target completes")
    else {
        panic!("the tilting target is split")
    };
    let certificate = DerivedEquivalenceCertificate::new(tilting, target)
        .expect("projective-dimension-one fixture has a certificate");
    assert!(certificate.verify());
    assert_eq!(certificate.graded_homotopy().len(), 3);
}

#[test]
fn projective_dimension_two_fixture_has_a_certificate_over_f2_and_f5() {
    for field in [f2(), f5()] {
        let algebra = an_with_relations(3, &[(0, 2)], field).expect("ab is a valid relation");
        let injectives: Vec<Module> = (0..3)
            .map(|vertex| Module::injective(&algebra, vertex))
            .collect();
        let module = direct_sum(&injectives.iter().collect::<Vec<_>>()).0;
        let limits = TiltingLimits {
            max_projective_dimension: 4,
            max_generation_steps: 8,
        };
        let ClassicalTiltingResult::Tilting(tilting) =
            ClassicalTiltingModule::classify(&module, limits).expect("fixture classifies")
        else {
            panic!("the dual fixture is classical tilting")
        };
        assert_eq!(
            tilting.projective_dimension(),
            2,
            "over F_{}",
            field.modulus()
        );
        let TargetPresentationOutcome::Presented(target) =
            present_target(&tilting, &TargetLimits::default()).expect("target completes")
        else {
            panic!("the dual target is split")
        };
        let certificate = DerivedEquivalenceCertificate::new(tilting, target)
            .expect("pd2 fixture has a certificate");
        assert!(certificate.verify(), "over F_{}", field.modulus());
        assert_eq!(certificate.graded_homotopy().len(), 5);
        assert!(
            certificate
                .graded_homotopy()
                .iter()
                .filter(|space| space.degree() != 0)
                .all(|space| space.quotient().dim() == 0)
        );
    }
}

#[test]
fn nonidentity_two_term_complex_and_chain_map_round_trip() {
    let (transport, module) = strict_regular_transport();
    let endo = EndoAlgebra::new(&module);
    let differential = endo
        .basis()
        .iter()
        .find(|map| !map.is_zero() && **map != identity(&module))
        .expect("A_2 has a nonidentity endomorphism")
        .clone();
    let complex = BoundedComplex::new(
        0,
        vec![module.clone(), module.clone()],
        vec![differential.clone()],
    )
    .expect("one differential forms a complex");
    let map = ChainMap::new(&complex, &complex, vec![differential.clone(), differential])
        .expect("the same endomorphism in both degrees is a chain map");
    let basic = BasicDecomposition::new(&module).expect("regular module is basic");
    let witness = AddClosureWitness::from_module(&module, &basic)
        .expect("membership decomposes")
        .expect("T lies in add(T)");
    let source =
        AddTComplex::new(complex, vec![witness.clone(), witness]).expect("witnessed source builds");
    let target_map = transport
        .forward_chain_map(&source, &source, &map)
        .expect("forward map transport builds");
    assert!(target_map.verify());
    let target = transport.forward(&source).expect("forward complex builds");
    let target_map_again = transport
        .forward_chain_map(&source, &source, &map)
        .expect("independent forward map transport builds");
    let source_product = map.then(&map).expect("source maps compose");
    let target_product = transport
        .forward_chain_map(&source, &source, &source_product)
        .expect("forward product transport builds");
    assert!(
        target_product.agrees_with(
            &target_map
                .then(&target_map_again)
                .expect("independent forward images compose")
        )
    );
    let reverse_map = transport
        .reverse_chain_map(&target, &target, &target_map)
        .expect("reverse map transport builds");
    assert!(reverse_map.verify());
    let reverse_map_again = transport
        .reverse_chain_map(&target, &target, &target_map_again)
        .expect("independent reverse map transport builds");
    let reverse_product = transport
        .reverse_chain_map(&target, &target, &target_product)
        .expect("reverse product transport builds");
    assert!(
        reverse_product.agrees_with(
            &reverse_map
                .then(&reverse_map_again)
                .expect("independent reverse images compose")
        )
    );
    let homotopy = ChainHomotopy::new(
        source.complex(),
        source.complex(),
        vec![zero_morphism(&module, &module).expect("zero map exists")],
    )
    .expect("zero component is a homotopy");
    let target_homotopy = transport
        .forward_homotopy(&source, &source, &homotopy)
        .expect("forward homotopy transport builds");
    assert!(target_homotopy.verify());
    let reverse_homotopy = transport
        .reverse_homotopy(&target, &target, &target_homotopy)
        .expect("reverse homotopy transport builds");
    assert!(reverse_homotopy.verify());
    assert!(transport.forward_cone(&source, &source, &map).is_ok());
    assert!(
        transport
            .reverse_cone(&target, &target, &target_map)
            .is_ok()
    );
    assert!(transport.forward_shift(&source, 2).is_ok());
    assert!(transport.reverse_shift(&target, -2).is_ok());
    assert!(transport.forward_direct_sum(&[&source, &source]).is_ok());
    assert!(transport.reverse_direct_sum(&[&target, &target]).is_ok());
    assert!(transport.source_round_trip(&source).is_ok());
    assert!(transport.target_round_trip(&target).is_ok());
}

#[test]
fn strict_domains_reject_the_first_bad_source_and_target_terms() {
    let (transport, module) = strict_regular_transport();
    let algebra = module.algebra().clone();
    let p0 = Module::projective(&algebra, 0);
    let p0_basic = BasicDecomposition::new(&p0).expect("P_0 is basic");
    let wrong_witness = AddClosureWitness::from_module(&p0, &p0_basic)
        .expect("membership decomposes")
        .expect("P_0 lies in add(P_0)");
    let wrong_source = AddTComplex::new(
        BoundedComplex::new(0, vec![p0], Vec::new()).expect("one term is a complex"),
        vec![wrong_witness],
    )
    .expect("the unrelated witness is internally valid");
    assert!(matches!(
        transport.forward(&wrong_source),
        Err(TransportError::SourceWitnessTarget { term: 0 })
    ));

    let target_algebra = transport.target().target();
    let nonprojective = (0..target_algebra.quiver().num_vertices())
        .map(|vertex| Module::simple(target_algebra, vertex))
        .find(|simple| matches!(resolve(simple, 0).end, ResolutionEnd::Cut { .. }))
        .expect("a nonsemisimple target has a nonprojective simple");
    assert!(matches!(
        transport.target_complex(
            BoundedComplex::new(0, vec![nonprojective], Vec::new()).expect("one term is a complex")
        ),
        Err(TransportError::TargetTermNotProjective { term: 0 })
    ));
}

#[test]
fn derived_certificate_and_transport_mutations_fail_verification() {
    let (tilting, target) = regular_certificate_inputs();
    let certificate = DerivedEquivalenceCertificate::new(tilting, target)
        .expect("regular generator has a certificate");
    assert!(certificate.verify());

    let mut changed = certificate;
    changed.graded_homotopy[0].degree = 1;
    assert!(!changed.verify());

    let (tilting, target) = regular_certificate_inputs();
    let mut changed = DerivedEquivalenceCertificate::new(tilting, target)
        .expect("regular generator has a certificate");
    let entry = changed.degree_zero.coordinates.get(0, 0);
    let field = changed.target.endo().field();
    changed
        .degree_zero
        .coordinates
        .set(0, 0, field.add(entry, field.one()));
    assert!(!changed.verify());

    let (transport, module) = strict_regular_transport();
    assert!(transport.verify());
    let basic = BasicDecomposition::new(&module).expect("regular module is basic");
    let witness = AddClosureWitness::from_module(&module, &basic)
        .expect("membership decomposes")
        .expect("T lies in add(T)");
    let source = AddTComplex::new(
        BoundedComplex::new(0, vec![module], Vec::new()).expect("one term is a complex"),
        vec![witness],
    )
    .expect("witnessed source builds");
    let mut target_complex = transport
        .forward(&source)
        .expect("forward transport builds");
    target_complex.terms[0].indices[0] = 1 - target_complex.terms[0].indices[0];
    assert!(!target_complex.verify());

    let mut changed = transport;
    changed.canonical_projectives[0] = Module::zero(changed.target.target());
    assert!(!changed.verify());
}